Three-dimensional data rendering method and device, equipment and medium

Abstract

The invention provides a three-dimensional data rendering method and device, equipment and a medium, and relates to the technical field of three-dimensional data processing. The method comprises the following steps: determining a rendering node and a rendering instruction through a control node, determining whether target cache data associated with a to-be-rendered data identifier exists in an intelligent cache system or not by a target rendering node, and extracting the target cache data from the intelligent cache system under the condition that the target cache data exists in the intelligent cache system, and enabling the target rendering node to perform rendering processing based on the extracted data so as to generate an image or video stream of the three-dimensional scene corresponding to the user access request. Through real-time analysis of node load conditions, rendering tasks are dynamically allocated to corresponding display card resources, parallel processing of single tasks is realized, collaborative rendering of multiple tasks can also be realized, the rendering efficiency and the resource utilization rate are improved, an intelligent cache system is utilized to automatically adjust a cache strategy according to data access frequency, and the resource utilization rate is improved. And thus, quick access of common data is ensured.

Description

Technical Field

[0001] This application belongs to the field of three-dimensional data processing technology, specifically relating to a three-dimensional data rendering method, apparatus, device, and medium. Background Technology

[0002] In the context of the digital age, the application of 3D data is becoming increasingly widespread, especially in fields such as digital twins, virtual reality (VR), and augmented reality (AR). These applications typically require the display and interaction of 3D data on web platforms to support remote access and collaboration. However, the management and rendering of 3D data in a web environment faces many challenges, including efficient data storage, fast retrieval, concurrent access by multiple users, and cross-platform compatibility.

[0003] Existing 3D data management and rendering systems typically employ a client-server architecture. The client handles user interaction, while the server handles data storage and rendering computation. For data management, some systems use relational databases or file systems to store 3D models and related data. For rendering, some systems use client-side rendering; while cloud rendering systems perform rendering tasks on the server side and then send the rendering results to the client as images or video streams. Regarding load balancing, some systems use hardware load balancers or software load balancing strategies to distribute user requests across different servers or service instances.

[0004] Existing technologies typically rely on a single server or graphics card for 3D rendering. When the number of users increases or the 3D scene becomes more complex, rendering performance can easily become a bottleneck. Existing systems often employ static load balancing strategies, which cannot intelligently schedule based on real-time server load and user request characteristics. This can easily lead to resource waste or overload, resulting in a degraded user experience. Furthermore, traditional 3D data management systems often lack efficient data organization and indexing mechanisms, making it difficult to perform fast retrieval and access on large-scale datasets. Summary of the Invention

[0005] This application provides a method, apparatus, device, and medium for rendering three-dimensional data, in order to solve the problems of insufficient data management, rendering performance, load balancing, scalability, and user interactivity in existing three-dimensional applications.

[0006] In a first aspect, this application provides a method for rendering three-dimensional data, applied to control nodes, the method comprising:

[0007] The access request corresponding to the user is determined, and the access request is analyzed and processed to obtain data information, which is used to indicate the request type and resource requirements of the access request;

[0008] When the request type is scene rendering, determine the real-time load of multiple graphics card nodes, and based on the multiple real-time loads and the resource requirements, determine at least one target rendering node and the rendering instructions for each target rendering node.

[0009] The rendering instruction is sent to the corresponding target rendering node, so that the target rendering node performs rendering processing based on the rendering instruction;

[0010] Optionally, determining at least one target rendering node and the rendering instructions for each target rendering node based on multiple real-time load conditions and the resource requirements includes:

[0011] Based on the resource requirements, determine the number of target rendering nodes;

[0012] When the number is one, the graphics card node with the lightest real-time load among the multiple real-time load conditions is taken as the target rendering node, and the resource requirement is determined as the rendering instruction of the target rendering node.

[0013] Optionally, the method further includes:

[0014] When the number is n, the n graphics card nodes with the lightest real-time load among the multiple real-time load conditions are selected as the n target rendering nodes, where n is an integer greater than 1;

[0015] The resource requirements are divided into n sub-resource requirements;

[0016] Establish the association between the n sub-resource requirements and the n target rendering nodes to obtain the rendering instructions for each target rendering node;

[0017] Optionally, determining the access request corresponding to the user includes:

[0018] The system receives access parameters input by the user on the interactive interface, the access parameters including: the user's identity information and access data information;

[0019] The user identity information is then processed for identity verification.

[0020] After the user's identity information is verified, the access request corresponding to the user is determined based on the access data information.

[0021] Secondly, this application provides a method for rendering three-dimensional data, applied to a target rendering node, the method comprising:

[0022] Receive rendering instructions sent by the control node, wherein the rendering instructions are used to indicate the corresponding data identifier to be rendered;

[0023] Determine whether there is target cache data associated with the data identifier to be rendered in the intelligent caching system. The intelligent caching system is used to cache popular data in the 3D data center. The access frequency of the popular data reaches a preset frequency.

[0024] If the target cache data exists in the intelligent caching system, the target cache data is extracted from the intelligent caching system, and rendering processing is performed based on the target cache data;

[0025] Optionally, the method further includes:

[0026] If the target cache data does not exist in the intelligent caching system, obtain 3D data that is associated with the identifier of the data to be rendered from the 3D data center;

[0027] Rendering processing is performed based on the aforementioned three-dimensional data;

[0028] Optionally, the method further includes:

[0029] During the rendering process, progress information is generated based on the current rendering progress, and the progress information is sent to the interactive interface so that the interactive interface can display the rendering progress and the current rendering scene based on the progress information.

[0030] Thirdly, this application provides a three-dimensional data rendering apparatus for use in a control node, the apparatus comprising:

[0031] The determination module is used to determine the access request corresponding to the user;

[0032] The analysis module is used to analyze and process the access request to obtain data information, which is used to indicate the request type and resource requirements of the access request.

[0033] The determining module is also used to determine the real-time load of multiple graphics card nodes when the request type is scene rendering.

[0034] The determining module is further configured to determine at least one target rendering node and the rendering instructions for each target rendering node based on multiple real-time load conditions and the resource requirements.

[0035] The sending module is used to send the rendering instructions to the corresponding target rendering node, so that the target rendering node performs rendering processing based on the rendering instructions;

[0036] Optionally, the determining module is further configured to determine the number of target rendering nodes based on the resource requirements;

[0037] The determining module is further configured to, when the number is one, select the graphics card node with the lightest real-time load among the plurality of real-time load conditions as the target rendering node.

[0038] The determining module is further configured to determine the resource requirement as the rendering instruction of the target rendering node;

[0039] Optionally, the device may also include: a segmentation module and a creation module;

[0040] The determining module is further configured to, when the number is n, select the n graphics card nodes with the lightest real-time load among the multiple real-time load conditions as the n target rendering nodes, where n is an integer greater than 1;

[0041] The segmentation module is used to segment the resource requirement to obtain n sub-resource requirements;

[0042] The establishment module is used to establish the association between the n sub-resource requirements and the n target rendering nodes, and to obtain the rendering instructions for each target rendering node.

[0043] Optionally, the device may also include: a receiving module and a verification module;

[0044] The receiving module is used to receive access parameters input by the user on the interactive interface, the access parameters including: the user's user identity information and access data information;

[0045] The verification module is used to perform identity verification processing on the user identity information;

[0046] The determining module is further configured to determine the access request corresponding to the user based on the access data information after the user identity information has been verified.

[0047] Fourthly, this application provides a three-dimensional data rendering apparatus applied to a target rendering node, the apparatus comprising:

[0048] The receiving module is used to receive rendering instructions sent by the control node, wherein the rendering instructions are used to indicate the corresponding data identifier to be rendered;

[0049] The determination module is used to determine whether there is target cache data associated with the data identifier to be rendered in the intelligent caching system. The intelligent caching system is used to cache popular data in the 3D data center. The access frequency of the popular data reaches a preset frequency.

[0050] The extraction module is used to extract the target cache data from the intelligent caching system when the target cache data exists in the intelligent caching system.

[0051] The rendering module is used to perform rendering processing based on the target cached data;

[0052] Optionally, the device may further include: an acquisition module;

[0053] The acquisition module is used to acquire, in the case that the target cache data does not exist in the intelligent caching system, three-dimensional data that is associated with the identifier of the data to be rendered from the three-dimensional data center;

[0054] The rendering module is also used to perform rendering processing based on the three-dimensional data;

[0055] Optionally, the device may also include: a generation module and a transmission module;

[0056] The generation module is used to generate progress information based on the current rendering progress during the rendering process.

[0057] The sending module is used to send the progress information to the interactive interface, so that the interactive interface can display the rendering progress and the current rendering scene based on the progress information.

[0058] Fifthly, this application provides a rendering device for three-dimensional data, comprising:

[0059] processor;

[0060] Memory;

[0061] The memory stores computer-executed instructions;

[0062] The at least one processor executes computer execution instructions stored in the memory, causing the at least one processor to perform a three-dimensional data rendering method as described in the first aspect and various possible implementations thereof or the second aspect and various possible implementations thereof.

[0063] In a sixth aspect, embodiments of the present invention provide a readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, provides a method for rendering three-dimensional data as described in the first aspect and various possible implementations thereof, or the second aspect and various possible implementations thereof.

[0064] This application provides a method, apparatus, device, and medium for rendering 3D data. A control node determines the rendering node and rendering instructions. The target rendering node determines whether target cache data associated with the identifier of the data to be rendered exists in the intelligent caching system. If target cache data exists in the intelligent caching system, it is extracted. The target rendering node then performs rendering processing based on the extracted data to generate an image or video stream of the 3D scene corresponding to the user's access request. By analyzing the node load in real time, rendering tasks are dynamically allocated to corresponding graphics card resources, enabling parallel processing of single tasks and collaborative rendering of multiple tasks, thus improving rendering efficiency and resource utilization. Furthermore, the intelligent caching system automatically adjusts the caching strategy based on data access frequency to ensure fast access to frequently used data. Attached Figure Description

[0065] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0066] Figure 1 This is an interactive illustration of a three-dimensional data rendering method provided in this application. Figure 1 ;

[0067] Figure 2 This is an interactive illustration of a three-dimensional data rendering method provided in this application. Figure 1 ;

[0068] Figure 3 This is a flowchart illustrating a three-dimensional data rendering method provided in this application;

[0069] Figure 4 This is a schematic diagram of the structure of a three-dimensional data rendering device provided in this application. Figure 1 ;

[0070] Figure 5 A schematic diagram of the structure of a three-dimensional data rendering device provided in this application Figure 2 ;

[0071] Figure 6 This is a schematic diagram of the structure of a three-dimensional data rendering device provided in this application.

[0072] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0073] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0074] The terms "first," "second," "third," "fourth," etc. (if present) in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the invention described herein can be implemented, for example, in orders other than those illustrated or described herein.

[0075] In this application, the terms "exemplary" or "for example" are used to indicate examples, illustrations, or descriptions. Any embodiment or design described as "exemplary" or "for example" in this application should not be construed as being more preferred or advantageous than other embodiments or designs. Specifically, the use of terms such as "exemplary" or "for example" is intended to present the relevant concepts in a specific manner.

[0076] First, let me explain the terms used in this application:

[0077] Distributed database systems: Distributed database systems typically use smaller computer systems. Each computer can be located in a separate place. Each computer may have a complete copy or a partial copy of the DBMS and its own local database. Many computers located in different locations are interconnected through a network to form a complete, global, logically centralized, and physically distributed large database.

[0078] The Hadoop Distributed File System (HDFS) is a distributed file system designed to run on general-purpose hardware. It shares many similarities with existing distributed file systems. However, its differences from other distributed file systems are also significant. HDFS is a highly fault-tolerant system, suitable for deployment on inexpensive machines. HDFS provides high-throughput data access, making it ideal for applications with large-scale datasets. HDFS relaxes some POSIX constraints to enable streaming file system data reading. HDFS was initially developed as the infrastructure for the Apache Nutch search engine project. HDFS is part of the Apache Hadoop Core project.

[0079] Ceph: Ceph is an open-source software-defined storage system that can be deployed on any x86 server and boasts excellent scalability, compatibility, and reliability. It provides file system services (cephfs), block services (rbd), and object storage services (rgw), forming a unified storage system. The Ceph architecture supports massive data storage; clusters can scale to petabyte capacity. The system itself has no hotspot data, data addressing relies on computation rather than lookup, and it can achieve self-maintenance and self-repair of data state.

[0080] Heartbeat detection is a monitoring mechanism widely used in Java programming and distributed systems. As the name suggests, heartbeat detection, like a heartbeat, is a mechanism for periodically sending signals or messages. In computer systems or network communications, it is typically used to detect the status and availability of system components, network connections, or remote nodes. In distributed systems, nodes need to maintain communication to collaboratively complete tasks. Heartbeat detection plays a crucial role here, detecting the status and availability of each node by periodically sending heartbeat signals.

[0081] Load balancing refers to the symmetrical arrangement of multiple servers into a single server cluster. Each server has equal status and can independently provide services without the assistance of other servers. Through load-sharing techniques, incoming requests are evenly distributed across a single server in this symmetrical structure, and the server receiving the request responds independently to the client's request. Load balancing distributes client requests evenly across the server array, thereby providing fast access to critical data and resolving issues related to high-concurrency access. This clustering technology achieves near-mainframe performance with minimal resources.

[0082] Least Recently Used (LRU) is a commonly used page replacement algorithm that selects the least recently used page for replacement. This algorithm assigns an access field to each page to record the time t elapsed since the page was last accessed. When a page needs to be replaced, it selects the existing page with the largest t value, i.e., the least recently used page, for replacement.

[0083] Time To Live (TTL): This field specifies the maximum number of network segments an IP packet is allowed to pass through before being dropped by a router. TTL is an 8-bit field in the IPv4 header.

[0084] In the context of the digital age, the application of 3D data is becoming increasingly widespread, especially in fields such as digital twins, VR, and AR. Existing 3D data management and rendering systems typically adopt a client-server architecture, usually relying on a single server or graphics card for 3D rendering. When the number of users increases or the 3D scene becomes more complex, rendering performance can easily become a bottleneck. Existing systems mostly use static load balancing strategies, which cannot intelligently schedule based on real-time server load and user request characteristics, easily leading to resource waste or overload and a degraded user experience. Furthermore, traditional 3D data management systems often lack efficient data organization and indexing mechanisms, making it difficult to quickly retrieve and access large-scale datasets.

[0085] To address the aforementioned issues, this application provides a method for rendering 3D data. The method involves a control node determining the rendering node and rendering instructions. The target rendering node determines whether target cache data associated with the identifier of the data to be rendered exists in the intelligent caching system. If target cache data exists in the intelligent caching system, it is extracted. The target rendering node then performs rendering processing based on the extracted data to generate an image or video stream of the 3D scene corresponding to the user's access request. By analyzing node load in real time, rendering tasks are dynamically allocated to corresponding graphics card resources, improving rendering efficiency and resource utilization. Furthermore, the intelligent caching system automatically adjusts the caching strategy based on data access frequency to ensure fast access to frequently used data.

[0086] The technical solution of this application and how the technical solution of this application solves the above-mentioned technical problems are described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will now be described with reference to the accompanying drawings.

[0087] Figure 1 This is an interactive illustration of a three-dimensional data rendering method provided in an embodiment of this application. Figure 1The interactive objects in this embodiment may include, for example, a control node and a target rendering node. Figure 1 As shown in the figure, this embodiment illustrates a method for rendering three-dimensional data, including:

[0088] S101: The control node determines the access request corresponding to the user.

[0089] In this context, the user's access request refers to the 3D data or 3D scene that the user wants to access, inputted from the interactive page. The control node can receive access requests sent from the interactive page and verify the user's identity based on the access request.

[0090] Understandably, the control node can authenticate a user's identity using authentication information provided by the user, such as username and password, digital certificate, or biometric information. The control node then compares this authentication information with the authorization information stored in the system to confirm the authenticity of the user's identity.

[0091] S102: The control node analyzes and processes the access request to obtain data information, which is used to indicate the request type and resource requirements of the access request.

[0092] The control node analyzes the request type and resource requirements to effectively allocate resources and execute requests, ensuring their legitimacy and security. Data information includes the request type and resource requirements. Request types can include querying data, rendering scenes, or extracting key information. Resource requirements refer to the resource configuration, graphics card usage, or memory space needed to process data; these can be resource identifiers such as file paths, database table names, or API endpoints. The scope of operations is not limited to a single resource; if operations need to be performed on a group of resources, the scope or conditions specified in the request can be analyzed. Data requirements, for certain types of requests, can be analyzed to specify data requirements such as filtering conditions, sorting requirements, and pagination parameters.

[0093] Specifically, the request type could be scene rendering, which refers to the process of converting a 3D scene or graphics into a 2D image. Its resource requirements could include, for example, a graphics processing unit (GPU) dedicated to graphics processing to accelerate the rendering process; a central processing unit (CPU) used to execute rendering algorithms and manage the scene; memory used to store scene data, textures, and rendering results; and disk space.

[0094] Understandably, after receiving a request, the control node can parse it to extract necessary information, such as the request type, parameters, and target resource. Then, based on the request's content and format, it determines the request type and evaluates the resources required to execute the request, allowing the server to allocate the necessary resources according to the evaluation results. Once allocated, the request can be executed on the allocated resources. The control node can monitor the request execution process, process the execution results, and return them to the user or perform further processing.

[0095] S103: When the request type is scene rendering, the control node determines the real-time load of multiple graphics card nodes.

[0096] The control node can query the load status of each graphics card node. Multiple graphics card nodes can reside on one or more physical or virtual servers, or a multi-GPU rendering cluster can consist of multiple server nodes equipped with high-performance graphics cards. Each node can independently execute 3D rendering tasks, without any restrictions. The multi-GPU rendering cluster can have a scalable architecture, dynamically adding or removing nodes based on system load. Each node can handle high-resolution and complex 3D scene rendering and supports various rendering technologies, such as ray tracing and shadow mapping. If the graphics card nodes are distributed across different physical or virtual servers, the control node can communicate with these nodes via the network to obtain the real-time status of each graphics card node.

[0097] Understandably, after collecting the data, the control node can analyze it to evaluate the real-time load of each graphics card node. For example, GPU utilization can be used to determine the percentage of time the GPU is currently executing tasks; high utilization might mean the node is busy processing other tasks, while low utilization might indicate the node is relatively idle. Video memory utilization can determine the usage of video memory; high utilization might limit the initiation of new tasks or affect task performance. Task queue length, if the graphics card node supports task queuing, reflects the number of tasks pending, thus indirectly reflecting the node's load. The real-time load of the current graphics card node can also be determined through metrics such as temperature and power consumption.

[0098] Specifically, the control node can make load balancing decisions based on real-time load evaluation results to optimize the allocation of rendering tasks. For example, it can assign new rendering tasks to GPU nodes with lower loads to balance the load across nodes; if the load on a node suddenly increases, the control node can migrate some tasks to other less busy nodes; or it can reserve a certain amount of resources for specific types of tasks to ensure that these tasks have sufficient computing resources when needed. The control node can also dynamically adjust its load balancing strategy according to the actual operation of the system, continuously monitor the real-time load of GPU nodes, and adjust the load balancing strategy based on feedback results. This can be achieved by adjusting rendering task parameters, optimizing rendering algorithms, or upgrading hardware to improve rendering efficiency and system performance.

[0099] S104: Based on multiple real-time load conditions and the resource requirements, the control node determines at least one target rendering node and the rendering instructions for each target rendering node.

[0100] The control node can receive user requests and intelligently allocate them to the most suitable rendering node. It makes decisions by monitoring the load of each node in real time. For example, the control node can use machine learning or predictive analytics to predict future load conditions and make resource adjustments in advance, thereby avoiding overload and optimizing response time. At the same time, it can monitor and dynamically adjust functions in real time to ensure that the system always runs in the optimal state.

[0101] Understandably, real-time monitoring can collect load information from each rendering node through a heartbeat detection mechanism, such as CPU utilization and memory usage. Request scheduling can then use load balancing algorithms to distribute user requests based on the real-time load of the rendering nodes. Prediction and adjustment can leverage machine learning models to predict node load and dynamically adjust resource allocation strategies, using high-performance servers and optimized network configurations to ensure the scheduler's response speed and decision accuracy. Furthermore, integrating advanced monitoring tools and predictive models enables intelligent load management.

[0102] Specifically, the control node can determine the target rendering node through an algorithm that minimizes rendering time or maximizes resource utilization. For example, it can be done in the following ways: round-robin, which simply assigns tasks to each node in turn, regardless of the node's current load; weighted round-robin, which assigns different weights to each node based on its processing capacity or current load, and then assigns tasks in round-robin according to the weights; minimum number of connections, which selects nodes based on the current number of rendering tasks or some form of "load" count; and lowest load priority, which directly selects the node with the lowest current load score.

[0103] After determining the target rendering node, the control node can generate and send rendering instructions for each node. Rendering instructions may include, for example, a detailed description of the rendering task, the path or reference to the input data, the expected path to the output data, rendering parameters or priority information, etc.

[0104] S105: The control node sends the rendering command to the corresponding target rendering node.

[0105] The control node can assign rendering tasks to target rendering nodes. The target rendering node receives the task assignment from the control node and performs rendering calculations according to the task requirements. Simultaneously, the target rendering node can also report its own load and task progress to the control node, enabling the control node to make more reasonable task allocation decisions.

[0106] Understandably, after receiving a rendering instruction, the target rendering node can send an acknowledgment message to the control node to indicate that the instruction has been successfully received. This acknowledgment message is optional and helps the control node monitor the distribution and execution of rendering tasks. If an error occurs during the sending or receiving of rendering instructions, such as a network interruption or the target node becoming unreachable, the control node can capture these errors and take appropriate error handling measures, such as retrying the sending, assigning the task to another node, or issuing a warning to the administrator.

[0107] Specifically, the control node can record information about the sending and receiving of rendering commands for subsequent monitoring, analysis, and auditing.

[0108] S106: The target rendering node receives a rendering instruction sent by the control node, the rendering instruction being used to indicate the corresponding data identifier to be rendered.

[0109] The target rendering node can receive rendering instructions from the control node and execute specific rendering tasks according to these instructions.

[0110] Understandably, target rendering nodes typically possess the hardware resources to perform rendering operations, such as a GPU, and the corresponding rendering engine or library to support complex graphics processing operations. Target rendering nodes can handle high-resolution and complex 3D scene rendering, and can support various rendering techniques, such as ray tracing and shadow mapping.

[0111] S107: The target rendering node determines whether there is target cache data associated with the identifier of the data to be rendered in the intelligent caching system. The intelligent caching system is used to cache popular data in the 3D data center, and the access frequency of the popular data reaches a preset frequency.

[0112] The intelligent caching system continuously monitors user access patterns to 3D data in the background, recording frequently accessed data and their frequency. It then applies caching algorithms, such as LRU and TTL, to dynamically adjust cached content, ensuring that frequently accessed data is prioritized. The system monitors data access frequency and automatically marks data with access frequencies reaching preset thresholds as frequently accessed data. Based on caching strategies, such as Least Recently Used (LRU) or LFU, the system stores frequently accessed data in the cache for fast access. As data access patterns change, the system dynamically updates the cache, removing less frequently accessed data and adding new frequently accessed data. Furthermore, the intelligent caching system can be tightly integrated with the rendering system to efficiently provide the required data during the rendering process.

[0113] Understandably, once the target rendering node receives the rendering instruction and determines the identifier of the data to be rendered, it can extract the identifier of the data to be rendered, extract the unique identifier associated with the data to be rendered from the rendering instruction, and use the identifier of the data to be rendered as the query key to initiate a query request to the intelligent caching system.

[0114] The caching system can also optimize caching strategies, select appropriate caching strategies based on the specific needs of the application and data access patterns, and use machine learning or data mining techniques to predict which data will become popular and load it into the cache in advance, or use a multi-level caching structure to store more frequently used data in a faster cache level. At the same time, the performance and hit rate of the caching system are monitored regularly and tuned as needed.

[0115] S108: If the target cache data exists in the intelligent caching system, the target rendering node extracts the target cache data from the intelligent caching system.

[0116] The intelligent caching system can check if there is target cache data that matches the query key. If it does, it is considered a cache hit; if it does not, it is considered a cache miss.

[0117] Specifically, if the cache is hit, the target rendering node will directly read the target cache data from the cache and use this data to perform rendering operations, which can significantly reduce data loading time and improve rendering efficiency. If the cache is missed, the target rendering node will need to load the data to be rendered from the original data source, such as the file system, database, or web server. After loading, this data can be added to the intelligent caching system for future use according to the caching strategy, which may depend on the caching strategy and available space.

[0118] S109: The target rendering node performs rendering processing based on the target cache data.

[0119] When the target rendering node finds target cache data associated with the identifier of the data to be rendered in the intelligent caching system, it will perform rendering processing based on this cache data.

[0120] Understandably, if the cached data is stored in a compressed or optimized format, the target rendering node can decompress it or convert it to a format that the rendering engine can directly use. This could include unpacking textures, loading model data, parsing shader programs, etc. The target rendering node can then combine the rendering parameters specified in the rendering instructions, such as viewpoint, lighting conditions, and material properties, with the cached data to configure the corresponding settings for the rendering engine.

[0121] Specifically, once the data is prepared and the rendering parameters are configured correctly, the target rendering node can call the rendering engine's API to perform rendering operations. The rendering engine will then use cached data and rendering parameters to generate the visual image. After rendering is complete, the target rendering node can further process the rendering results, such as applying post-processing effects, saving the results to a file, or storing them in memory.

[0122] In one possible implementation, the target rendering node can feed back rendering results or state information during the rendering process to the control node, allowing the control node to perform subsequent processing or adjustments. If incomplete or outdated cached data is detected during rendering, the target rendering node can trigger a cache update mechanism to load the latest data from the original data source and update the cache. By performing rendering processing based on target cached data, the target rendering node can generate high-quality visual images faster, while reducing dependence on the original data source and the overall system load, making the entire rendering process more efficient, reliable, and scalable.

[0123] The authorization and authentication method based on a capability open gateway provided in this embodiment monitors multiple graphics card nodes through a control node. Upon receiving a user's access request, the access request is analyzed to determine its access type and resource requirements. A corresponding target rendering node is then assigned to the access request. The target rendering node identifies and extracts target cache data from the intelligent caching system and performs rendering processing on the extracted data to generate an image or video stream of the 3D scene corresponding to the user's access request. By dynamically allocating rendering tasks to the corresponding graphics card resources, rendering efficiency and resource utilization are improved. Furthermore, the intelligent caching system caches the target rendering data to ensure fast access to frequently used data.

[0124] Figure 2 This is an interactive illustration of a three-dimensional data rendering method provided in an embodiment of this application. Figure 2 This embodiment is... Figure 1 Based on the embodiments, a method for rendering three-dimensional data is described in detail. Figure 2As shown in the figure, this embodiment illustrates a method for rendering three-dimensional data, including:

[0125] S201: The control node receives access parameters input by the user on the interactive interface, the access parameters including: the user's identity information and access data information.

[0126] User identity information is a set of data used to uniquely identify a user, and may include, for example, usernames, biometric information, passwords or encryption keys associated with the user's identity. Access data information refers to data related to the specific resource a user requests access to or the operation they wish to perform. This may include, for example, resource identifiers, operation types, parameters / query conditions, or permission requirements.

[0127] Understandably, the control node can receive access parameters input by the user through the interactive interface, verify the validity of the user's identity information, ensure that the user is a legitimate user recognized by the system, check whether the user has the right to access the requested resource or perform the requested operation based on the user's identity information and the permission requirements in the access data information, and can return the operation result or accessed data to the user, and update the user's session state when necessary.

[0128] S202: The control node performs identity verification processing on the user's identity information.

[0129] The authentication process can include password verification, token verification, or biometric verification. If a password is used as the authentication credential, the control node can compare the password entered by the user with the password stored in the system. If the system uses session tokens or cookies as authentication mechanisms, the control node can verify the validity of these tokens, which may include checking whether the token has expired, been tampered with, and is associated with the user account. If the system supports biometric authentication, the control node can compare the received biometric information with the biometric template stored by the user in the system.

[0130] Understandably, if authentication is successful, the control node will allow the user to continue performing subsequent operations, such as accessing data or executing commands. In some cases, the control node will also update the user's session information, such as session validity and user permissions. If authentication fails, the control node can deny the user's access request and return an error message to the user. Depending on the system's security policy, the control node can also take backup security measures, such as logging failed login attempts or temporarily locking user accounts.

[0131] S203: After the user's identity information is verified, the control node determines the access request corresponding to the user based on the access data information.

[0132] The control node receives and verifies user input to ensure the legitimacy of the request. After successful user login and verification, the user request can be encapsulated into a standard HTTP request and converted into a computer access language.

[0133] Understandably, the control node can parse the access data information submitted by the user, which may include resource identifiers, operation types, parameters / query conditions, and possible permission requirements. This data can be used to construct the user's access request.

[0134] Specifically, after determining a user's access request, the control node may check whether the user has the necessary permissions to execute the request. This can be done by checking the user's role, permission level, or specific permission flags to determine if the user is authorized to access the requested resource or perform the requested operation. If the user has the necessary permissions, the control node can construct a complete access request based on the parsed access data and the user's identity information. This access request will contain sufficient information for the system to accurately identify the user's intent and execute the corresponding operation. After constructing the access request, the control node may route the request to the appropriate part of the system for processing.

[0135] S204: The control node analyzes and processes the access request to obtain data information, which is used to indicate the request type and resource requirements of the access request.

[0136] S205: When the request type is scene rendering, the control node determines the real-time load of multiple graphics card nodes.

[0137] S206: Based on multiple real-time load conditions and the resource requirements, the control node determines at least one target rendering node and the rendering instructions for each target rendering node.

[0138] S207: The control node sends the rendering command to the corresponding target rendering node.

[0139] S208: The target rendering node receives a rendering instruction sent by the control node, the rendering instruction being used to indicate the corresponding data identifier to be rendered.

[0140] S209: The target rendering node determines whether there is target cache data associated with the identifier of the data to be rendered in the intelligent caching system. The intelligent caching system is used to cache popular data in the 3D data center, and the access frequency of the popular data reaches a preset frequency.

[0141] S210: If the target cache data exists in the intelligent caching system, the target rendering node extracts the target cache data from the intelligent caching system.

[0142] S211: The target rendering node performs rendering processing based on the target cache data.

[0143] Steps S204-S211 are similar to steps S102-S109 above, and will not be described again here.

[0144] S212: If the target cache data does not exist in the intelligent caching system, the target rendering node obtains the three-dimensional data that is associated with the identifier of the data to be rendered from the three-dimensional data center.

[0145] Among them, a 3D data center refers to a system that is responsible for the centralized storage, management and maintenance of all 3D data assets, such as 3D models, texture maps, animation sequences and other metadata related to 3D scenes.

[0146] Understandably, a 3D data center can be built on a distributed database system to ensure the flexibility of horizontal data scalability and the efficiency of data access. The database can support high-concurrency access to handle the demands of a large number of users simultaneously accessing and retrieving data. The system can employ distributed storage technologies, such as HDFS or Ceph, to distribute data across multiple physical nodes, providing data redundancy and fault tolerance. A database management system can then be used to organize, index, and query the 3D data. A RESTful API or Graph QL interface can be provided for other system components to call and retrieve data.

[0147] Specifically, after confirming that the target cache data cannot be found in the intelligent caching system, the target rendering node prepares a data request based on the identifier of the data to be rendered. This request can specify detailed information about the 3D data to be retrieved, such as the data identifier, required format, and data volume.

[0148] Once the request is confirmed, the target rendering node establishes a communication connection with the 3D data center. This can be done through network requests, message queues, remote procedure calls, or other appropriate communication mechanisms. After receiving the request, the 3D data center can retrieve the corresponding 3D data based on the identifiers and parameters specified in the request. This can be done by querying a database, file system, or specific data storage service.

[0149] Once the data is retrieved, the 3D data center can transmit the data to the target rendering node. Data transmission can be synchronous, meaning the target rendering node waits for the data to be completely transmitted before continuing processing, or asynchronous, meaning the target rendering node begins processing as soon as it receives a portion of the data or as soon as it starts receiving data; there is no restriction on this.

[0150] The target rendering node can receive 3D data transmitted from the 3D data center and perform necessary processing, such as data decompression, format conversion, and data verification, to ensure that the data meets the rendering requirements.

[0151] S213: The target rendering node performs rendering processing based on the three-dimensional data.

[0152] Based on 3D data, the target rendering node can construct a rendering scene in memory. This includes placing 3D models into the scene, setting transformation parameters such as the model's position, rotation, and scaling, and applying visual effects such as textures and materials. Simultaneously, the rendering node can configure environmental parameters such as lighting and camera settings to simulate real-world lighting conditions and viewing angles.

[0153] Understandably, after rendering the basic image or video stream, the target rendering node may apply some post-processing effects to enhance the quality of the image or video stream, such as color correction, depth of field effects, anti-aliasing, etc.

[0154] In one possible implementation, the rendering node can output the rendered image or video stream to the display screen for the user to view.

[0155] S214: During the rendering process, the target rendering node generates progress information based on the current rendering progress.

[0156] The target rendering node generates progress information based on the current rendering progress. This progress information is used by the user to understand the completion status of the task and make decisions accordingly, such as whether to continue waiting or cancel the task.

[0157] Understandably, the target rendering node can define one or more metrics to evaluate rendering progress, such as the number of frames rendered, the number of models processed, and the percentage of rendering stages completed. During the rendering process, the target rendering node can continuously monitor its internal state, including the amount of data processed and the rendering tasks completed, and generate progress information.

[0158] Specifically, the target rendering node can calculate the current rendering progress based on defined metrics and monitored rendering process information. After calculating the current rendering progress, the target rendering node can generate corresponding progress information, which can be presented in text form such as "60% complete", graphical form, or a combination of both.

[0159] S215: The target rendering node sends the progress information to the interactive interface, so that the interactive interface can display the rendering progress and the current rendering scene based on the progress information.

[0160] The target rendering node can send encapsulated data to the interactive interface through a pre-defined communication channel. After receiving the data from the target rendering node, the interactive interface can parse it to extract progress information and rendered scene images.

[0161] Understandably, the interactive interface can update the user interface to display the current rendering progress and rendering scene based on the parsed progress information and rendered scene images. This can be achieved, for example, by updating the progress bar, displaying the remaining time, or rendering scene images in the canvas or image control.

[0162] Specifically, it can provide a smooth user experience. The target rendering node can periodically, such as every second or at certain intervals, send updated progress information and rendered scene images to the interactive interface. The interactive interface can also update its displayed content in real time to reflect the latest rendering status and progress.

[0163] In one possible implementation, during the rendering process, when the user wants to pause, continue, or cancel the rendering task, the interactive interface can receive the user's operation command and pass it to the target rendering node for corresponding processing to complete the interaction with the user.

[0164] This embodiment provides a method for rendering 3D data. When the target cache data is not present in the intelligent caching system, 3D data associated with the identifier of the data to be rendered is obtained from the 3D data center. The target rendering node then performs rendering processing based on this 3D data. Through a distributed 3D data management system, large-scale 3D datasets can be efficiently stored, indexed, and retrieved across multiple servers and storage devices, dynamically expanding storage capacity and improving data access speed.

[0165] Figure 3 This is a schematic diagram illustrating the process of a control node confirming the number of target rendering nodes in a three-dimensional data rendering method provided in this embodiment. Figure 1 and Figure 2 Based on the embodiments, a method for rendering three-dimensional data is described in detail. The process by which the control node determines the number of target rendering nodes based on the resource requirements of the access request is described in detail, and the specific process may include:

[0166] S301: Determine the number of target rendering nodes based on the resource requirements.

[0167] Resource requirements may include, for example, the resource requirements of rendering tasks, the performance of rendering nodes, cost-effectiveness, and the scalability of the system.

[0168] Understandably, the control node can evaluate the resource requirements of a rendering task, assessing the computational resources needed, such as CPU, GPU, memory, and storage, and determining the time required to complete the task. Subsequently, the control node determines the performance of the rendering nodes, including understanding the hardware specifications of each node (CPU, GPU, memory, and storage); and evaluating the processing capacity of each node for a specific rendering task, including the number of frames per second and rendering speed. Based on these assessments, a load balancing algorithm can be used to determine the target number of rendering nodes.

[0169] S302: When the number is one, the graphics card node with the lightest real-time load among the multiple real-time load conditions is selected as the target rendering node.

[0170] The control node can monitor the load of all graphics card nodes in the system in real time, analyze the collected load data, and determine which graphics card nodes are currently in a relatively idle state, i.e., the lightest real-time load.

[0171] Understandably, the node with the lightest real-time load is currently handling the fewest tasks, and therefore can respond to new rendering tasks more quickly.

[0172] Specifically, since load conditions change over time, load data can be updated periodically, and the lightest-loaded node can be reassessed. If a node is currently lightly loaded, but is performing other important or high-priority tasks, its priority can be determined based on the load strategy, and then it can be decided whether to use it as a rendering node.

[0173] S303: The resource requirements are determined as the rendering instructions for the target rendering node.

[0174] Among them, rendering instructions refer to the information required to complete the rendering task, which may include input data, output requirements, and various parameters and configurations during the rendering process.

[0175] Understandably, the control center can evaluate the specific requirements of the rendering task, determine the required rendering parameters and output requirements, and determine the rendering strategy based on resource needs and system capabilities.

[0176] Specifically, the control node can write rendering instructions into scripts or configuration files. For example, it can use the syntax and format supported by the rendering software to define input data, rendering parameters, output requirements, and special instructions. The rendering script or configuration file is then submitted to the target rendering node, which then performs the rendering work according to the rendering instructions.

[0177] S304: When the number is n, the n graphics card nodes with the lightest real-time load among the multiple real-time load situations are taken as the n target rendering nodes, where n is an integer greater than 1.

[0178] In the case of n nodes (where n is an integer greater than 1), selecting the n graphics card nodes with the lightest real-time load as target rendering nodes can ensure that rendering tasks can be distributed to the least busy nodes in the current system, thereby optimizing resource utilization and potentially shortening the overall rendering time.

[0179] Understandably, real-time load data of each graphics card node can be collected periodically through system monitoring tools or custom scripts. The control node can then analyze the collected load data to determine the current load status of each graphics card node.

[0180] Specifically, the control node can sort the graphics card nodes from lightest to heaviest load based on the analysis results, and select the top n nodes in the sorted list as target rendering nodes. If there are multiple nodes with similar loads and relatively light loads, further filtering can be performed based on other factors, such as node stability, historical performance, and network connection quality.

[0181] S305: The resource requirements are divided into n sub-resource requirements.

[0182] The task to be rendered is assigned to n selected target rendering nodes. The control center can assign a single task to a single node or split the task into multiple subtasks and assign them to multiple nodes for parallel processing, depending on the complexity of the task and the performance of the node.

[0183] Understandably, the control center can analyze the overall resource requirements of rendering tasks, such as computing resources, memory, storage space, network bandwidth, and specific requirements of the rendering tasks. Based on the characteristics of the rendering tasks and the system resource situation, it can determine an appropriate partitioning strategy. The partitioning strategy can be based on various factors, such as scene complexity, rendering hierarchy, task parallelism, and data independence.

[0184] Specifically, the rendering scene or task can be divided into n smaller parts (subtasks). This can be spatial, such as dividing a large scene into multiple regions or layers; temporal, such as dividing a long animation sequence into multiple frames or segments; or task-type-based, such as breaking down the rendering task into subtasks like geometry processing, lighting calculation, and texture compositing. Corresponding resource requirements are then allocated to each subtask, which may include determining the amount of computing resources, memory usage, storage space requirements, and software or hardware requirements for each subtask.

[0185] In one possible implementation, the control center can assign the divided subtasks to n target rendering nodes, and can use a task scheduling system or rendering management software to monitor and manage the execution status of each subtask, and can adjust resource allocation or reallocate tasks as needed.

[0186] S306: Establish the association between the n sub-resource requirements and the n target rendering nodes to obtain the rendering instructions for each target rendering node.

[0187] The control center can establish the association between the n sub-resource requirements and the n target rendering nodes based on the characteristics of the sub-resource requirements and the capabilities of the target rendering nodes. The association strategy can be based on factors such as load balancing, resource utilization, task priority, and data locality.

[0188] Understandably, the control center can compare the requirements of each subtask with the available resources of the nodes to find the most suitable pairing and allocate the n sub-resource requirements to n target rendering nodes. For example, algorithms can be used to optimize the allocation process to minimize the overall rendering time, maximize resource utilization, or meet other optimization objectives.

[0189] Specifically, for each target rendering node, the control center can generate corresponding rendering instructions based on its allocated sub-resource requirements. These instructions can contain rendering information to ensure the node can accurately execute rendering tasks. During the rendering process, the control center can monitor the status and performance of each target rendering node in real time. If anomalies are detected, such as node failure, insufficient resources, or rendering errors, remedial measures can be taken, such as reallocating tasks, increasing resources, or adjusting rendering parameters, to dynamically adjust the allocation strategy.

[0190] After all target rendering nodes have completed their assigned subtasks, the control center can collect and integrate the rendering results. For example, multiple output files can be merged into a final product, or post-processing software can be used to optimize and adjust the rendering results, ensuring that the rendering tasks can be executed efficiently and accurately, and making full use of system resources to shorten rendering time and improve rendering quality.

[0191] This embodiment provides a three-dimensional data rendering method that determines rendering nodes and rendering instructions through control nodes, analyzes server load, user request characteristics and network status in real time, dynamically allocates rendering tasks to the most suitable graphics card resources, divides the resource requirements to obtain n sub-resource requirements, decomposes large or complex rendering tasks into multiple smaller, more manageable parts, achieves parallel processing of a single task through a multi-graphics card rendering cluster, and can also achieve collaborative rendering of multiple tasks, thereby improving rendering efficiency and resource utilization.

[0192] Figure 4 A schematic diagram of the structure of a three-dimensional data rendering device provided in this application Figure 1 This device is used in control nodes. For example... Figure 4 As shown, this embodiment provides a three-dimensional data rendering device 400, including:

[0193] Module 401 is used to determine the access request corresponding to the user.

[0194] Analysis module 402 is used to analyze and process the access request to obtain data information, which is used to indicate the request type and resource requirements of the access request.

[0195] The determining module 401 is further configured to determine the real-time load of multiple graphics card nodes when the request type is scene rendering.

[0196] The determining module 401 is further configured to determine at least one target rendering node and the rendering instructions for each target rendering node based on multiple real-time load conditions and the resource requirements.

[0197] The sending module 403 is used to send the rendering instruction to the corresponding target rendering node, so that the target rendering node performs rendering processing based on the rendering instruction;

[0198] Optionally, the determining module 401 is further configured to determine the number of target rendering nodes based on the resource requirements;

[0199] The determining module 401 is further configured to, when the number is one, select the graphics card node with the lightest real-time load among the plurality of real-time load conditions as the target rendering node.

[0200] The determining module 401 is further configured to determine the resource requirement as the rendering instruction of the target rendering node;

[0201] Optionally, the device may further include: a segmentation module 404 and a creation module 405;

[0202] The determining module 401 is further configured to, when the number is n, select the n graphics card nodes with the lightest real-time load among the multiple real-time load situations as the n target rendering nodes, where n is an integer greater than 1;

[0203] The segmentation module 404 is used to segment the resource requirement to obtain n sub-resource requirements;

[0204] The establishment module 405 is used to establish the association between the n sub-resource requirements and the n target rendering nodes, and to obtain the rendering instructions for each target rendering node.

[0205] Optionally, the device may also include: a receiving module 406 and a verification module 407;

[0206] The receiving module 406 is used to receive access parameters input by the user on the interactive interface, the access parameters including: the user's user identity information and access data information;

[0207] The verification module 407 is used to perform identity verification processing on the user identity information;

[0208] The determining module 401 is further configured to determine the access request corresponding to the user based on the access data information after the user identity information has been verified.

[0209] Figure 5 A schematic diagram of the structure of a three-dimensional data rendering device provided in this application Figure 2 This device is applied to the target rendering node. For example... Figure 5 As shown, this embodiment provides a three-dimensional data rendering device 500, including:

[0210] The receiving module 501 is used to receive rendering instructions sent by the control node, wherein the rendering instructions are used to indicate the corresponding data identifier to be rendered;

[0211] The determination module 502 is used to determine whether there is target cache data associated with the data identifier to be rendered in the intelligent caching system. The intelligent caching system is used to cache popular data in the three-dimensional data center. The access frequency of the popular data reaches a preset frequency.

[0212] Extraction module 503 is used to extract the target cache data from the intelligent caching system when the target cache data exists in the intelligent caching system;

[0213] Rendering module 504 is used to perform rendering processing based on the target cache data;

[0214] Optionally, the device may further include: an acquisition module 505;

[0215] The acquisition module 505 is used to acquire, in the case that the target cache data does not exist in the intelligent caching system, three-dimensional data that is associated with the identifier of the data to be rendered from the three-dimensional data center;

[0216] The rendering module 504 is also used to perform rendering processing based on the three-dimensional data;

[0217] Optionally, the device may further include: a generation module 506 and a transmission module 507;

[0218] The generation module 506 is used to generate progress information based on the current rendering progress during the rendering process;

[0219] The sending module 507 is used to send the progress information to the interactive interface so that the interactive interface can display the rendering progress and the current rendering scene based on the progress information.

[0220] Figure 6 This is a schematic diagram of the structure of a three-dimensional data rendering device provided in this application. Figure 6 As shown, this application provides a three-dimensional data rendering device. The three-dimensional data rendering device 600 includes: a receiver 601, a transmitter 602, a processor 603, and a memory 604.

[0221] Receiver 601 is used to receive instructions and data;

[0222] Transmitter 602 is used to send commands and data;

[0223] Memory 604 is used to store instructions executed by the computer;

[0224] The processor 603 is used to execute computer execution instructions stored in the memory 604 to implement the various steps performed by the various execution entities of the three-dimensional data rendering method in the above embodiments. For details, please refer to the relevant descriptions in the foregoing embodiments of the three-dimensional data rendering method.

[0225] Alternatively, the memory 604 can be either standalone or integrated with the processor 603.

[0226] When the memory 604 is set up independently, the electronic device also includes a bus for connecting the memory 604 and the processor 603.

[0227] This application also provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement a three-dimensional data rendering method as described above by a three-dimensional data rendering device.

[0228] It will be understood by those skilled in the art that all or some of the steps, systems, or apparatuses disclosed above, and their functional modules / units, can be implemented as software, firmware, hardware, or suitable combinations thereof. In hardware implementations, the division between functional modules / units mentioned in the above description does not necessarily correspond to the division of physical components; for example, a physical component may have multiple functions, or a function or step may be performed collaboratively by several physical components. Some or all physical components may be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application-specific integrated circuit (ASIC). Such software may be distributed on a computer-readable medium, which may include computer storage media (or non-transitory media) and communication media (or transient media). As is known to those skilled in the art, the term computer storage media includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storing information (such as computer-readable instructions, data structures, program modules, or other data). Computer storage media include, but are not limited to, RAM, ROM, EEPROM, flash memory or other memory technologies, CD-ROM, digital versatile disc (DVD) or other optical disc storage, magnetic cartridges, magnetic tape, disk storage or other magnetic storage devices, or any other medium that can be used to store desired information and can be accessed by a computer. Furthermore, it is well known to those skilled in the art that communication media typically contain computer-readable instructions, data structures, program modules, or other data in modulated data signals such as carrier waves or other transmission mechanisms, and may include any information delivery medium.

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

[0230] It should be understood that this application is not limited to the precise structure described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this application is limited only by the appended claims.

Claims

1. A method of rendering three-dimensional data, characterized by, The method applied to a control node comprises: determining an access request corresponding to a user, and performing analysis processing on the access request to obtain data information, the data information being used to indicate a request type and resource requirement of the access request; in a case where the request type is scene rendering, determining real-time load conditions of a plurality of graphics card nodes, and determining at least one target rendering node and rendering instructions of each target rendering node based on the plurality of real-time load conditions and the resource requirement; sending the rendering instructions to the corresponding target rendering node, so that the target rendering node performs rendering processing based on the rendering instructions.

2. The method of claim 1, wherein, The determining at least one target rendering node and rendering instructions of each target rendering node based on the plurality of real-time load conditions and the resource requirement comprises: determining a number of the target rendering nodes according to the resource requirement; in a case where the number is one, taking a graphics card node with a lightest real-time load condition in the plurality of real-time load conditions as the target rendering node, and determining the resource requirement as the rendering instruction of the target rendering node.

3. The method of claim 2, wherein, The method further comprises: in a case where the number is n, taking n graphics card nodes with lightest real-time load conditions in the plurality of real-time load conditions as the n target rendering nodes, wherein n is an integer greater than 1; performing segmentation processing on the resource requirement to obtain n sub-resource requirements; establishing an association relationship between the n sub-resource requirements and the n target rendering nodes to obtain the rendering instruction of each target rendering node.

4. The method of claim 1, wherein, The determining an access request corresponding to a user comprises: receiving an access parameter input by a user on an interactive interface, the access parameter comprising user identity information and access data information of the user; performing identity authentication processing on the user identity information; after the user identity information is verified, determining the access request corresponding to the user based on the access data information.

5. A rendering method of three-dimensional data, characterized by, The method applied to a target rendering node comprises: receiving a rendering instruction sent by a control node, the rendering instruction being used to indicate a corresponding to-be-rendered data identifier; determining whether target cache data associated with the to-be-rendered data identifier exists in an intelligent cache system, the intelligent cache system being used to cache popular data in a three-dimensional data center, an access frequency of the popular data reaching a preset frequency; in a case where the target cache data exists in the intelligent cache system, extracting the target cache data from the intelligent cache system, and performing rendering processing based on the target cache data.

6. The method of claim 5, wherein, The method further comprises: in a case where the target cache data does not exist in the intelligent cache system, acquiring three-dimensional data associated with the to-be-rendered data identifier from the three-dimensional data center; performing rendering processing based on the three-dimensional data.

7. The method of claim 5, wherein, The method further comprises: in a process of performing rendering processing, generating progress information based on a current rendering progress, and sending the progress information to an interactive interface, so that the interactive interface displays the rendering progress and a current rendering scene based on the progress information.

8. A rendering apparatus of three-dimensional data, characterized by comprising: The device applied to a control node comprises: A determining module is configured to determine an access request corresponding to a user; An analyzing module is configured to analyze and process the access request to obtain data information, which is used to indicate a request type and resource requirement of the access request; The determining module is further configured to determine real-time load conditions of a plurality of GPU nodes in a case where the request type is scene rendering; The determining module is further configured to determine at least one target rendering node and rendering instructions of each target rendering node based on the resource requirement and the plurality of real-time load conditions; A sending module is configured to send the rendering instructions to the corresponding target rendering node, so that the target rendering node performs rendering processing based on the rendering instructions.

9. A rendering apparatus of three-dimensional data, characterized by comprising: The device is applied to a target rendering node and includes: A receiving module is configured to receive rendering instructions sent by a control node, wherein the rendering instructions are used to indicate a corresponding to-be-rendered data identifier; A determining module is configured to determine whether target cache data associated with the to-be-rendered data identifier exists in an intelligent cache system, wherein the intelligent cache system is used to cache popular data in a three-dimensional data center, and an access frequency of the popular data reaches a preset frequency; An extracting module is configured to extract the target cache data from the intelligent cache system in a case where the target cache data exists in the intelligent cache system; A rendering module is configured to perform rendering processing based on the target cache data.

10. A rendering device of three-dimensional data, characterized by, comprise: a memory; a processor; wherein the memory stores computer execution instructions; the processor executes the computer execution instructions stored in the memory to implement the rendering method of three-dimensional data according to any one of claims 1-7.

11. A computer readable storage medium, characterized in that, The computer readable storage medium stores computer execution instructions, and the computer execution instructions are executed by the processor to implement the rendering method of three-dimensional data according to any one of claims 1-7.

Images