Internet-based 3D visual modeling method

Abstract

The invention particularly relates to a 3D visual modeling method based on the Internet, and relates to the technical field of distributed rendering, and the method comprises the steps: task analysis and intelligent splitting; dynamic resource evaluation and selection; distributing and scheduling dynamic tasks; and performing task execution and process monitoring. According to the method, the three-dimensional complexity evaluation model is constructed, geometry, material texture and illumination special effect complexity are quantified into calculated amount weight values, a unified scientific standard is provided for task splitting, and traditional fuzzy judgment depending on subjective experience is avoided; and a splitting mode is dynamically selected in combination with scene complexity variance: uniform splitting is carried out when the complexity difference is small, the tile size is adjusted according to local complexity when the difference is large, and long-tail tasks are eliminated from the source.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of distributed rendering, and particularly relates to a 3D visualization modeling method based on the Internet. BACKGROUND

[0002] With the deep application of 3D visualization technology in the fields of architectural design, film special effects, virtual simulation, etc., the scene complexity continues to increase, not only the geometric model precision and material texture resolution are significantly improved, but also the computationally intensive lighting effects such as global illumination, volume light, and particle system are widely applied. The computing power of a single server cannot meet the efficient rendering requirements, and distributed rendering has become the core architecture to support large-scale 3D visualization modeling.

[0003] However, the existing distributed method has obvious limitations in the task splitting link. It usually adopts fixed-size tiles for uniform splitting, ignoring the computational load difference of different regions of the scene, resulting in overloading of complex region sub-tasks to form long-tail tasks, and wasting of resources in simple regions. At the same time, the scene complexity evaluation relies on artificial subjective experience, lacks a unified quantitative standard, and the splitting rationality cannot be guaranteed, which directly restricts the overall rendering efficiency of the cluster.

[0004] In addition, the resource matching, task scheduling and result processing capabilities of the existing method are difficult to adapt to the needs of the Internet scene: resource selection only depends on static hardware parameters such as CPU core number and memory capacity, without considering real-time load (such as CPU utilization and memory occupancy) and network quality of nodes, which is prone to resource mismatch such as overloading of high-performance nodes and idling of low-latency nodes. The task scheduling strategy is single and cannot adapt to the heterogeneous cluster where high-end GPUs and ordinary CPUs coexist. In addition, there is a lack of priority management, so that urgent tasks cannot be executed in priority and long-tail tasks are prone to block the queue. The fault tolerance mechanism only uses simple retry, which causes resource waste as the executed tasks need to be rendered again. The tile seams are obvious during result synthesis, and there is no unified post-processing process, so the output quality stability is poor, which is difficult to meet the actual needs of high-quality 3D visualization modeling.

[0005] Therefore, the 3D visualization modeling method based on the Internet is proposed to solve the above-mentioned problems. SUMMARY

[0006] The purpose of the present application is to solve the above problems, and the 3D visualization modeling method based on the Internet is proposed.

[0007] In order to achieve the above purpose, the present application adopts the following technical solutions: The 3D visualization modeling method based on the Internet comprises: Task analysis and intelligent splitting: By analyzing 3D rendering requests and quantitatively assessing scene complexity, an adaptive tile splitting strategy is adopted to split tasks into parallel, load-balanced, and low-communication-overhead subtasks. Dynamic resource assessment and selection: Based on the static hardware information and dynamic performance profile of the sub-server, the target node pool is selected and determined through weight calculation to achieve the initial matching of tasks and resources; Dynamic task allocation and scheduling: Construct task packages, allocate tasks based on the performance differences of cluster nodes using either a greedy or balanced allocation strategy, and ensure load balancing and efficiency through queue priority management; Task execution and process monitoring: The sub-server executes 3D rendering tasks and reports progress. The main server tracks the task status through multi-dimensional monitoring and handles anomalies with the help of a failover mechanism to ensure reliable task execution.

[0008] Preferably, the task analysis and intelligent decomposition specifically include: After receiving a user's 3D rendering request, the main server first parses different types of scene files through the format adaptation module and extracts the scene topology, asset reference path, and rendering parameter set. Construct a three-dimensional complexity evaluation model, using geometric complexity. Material texture complexity Complexity of lighting effects Calculate the computational weight value for each scenario. ; Preset geometric complexity respectively Material texture complexity Complexity of lighting effects After determining the weighting factors, each weight is multiplied by its corresponding weighting factor, and the results are summed to obtain the calculated weight value. .

[0009] Preferably, the method further includes an adaptive tile splitting strategy, the contents of which are as follows: Basic rule: First determine the minimum and maximum tile sizes; When the scene complexity variance is ≤1.2, the number of tiles is determined by equal grid splitting. ; Adaptive non-uniform splitting process: The main server performs pre-sampling analysis on the scene, dividing the image into a temporary grid of 128×128 pixels, and calculates the local complexity of each temporary grid. ; If the local complexity of the obtained temporary mesh is When the value is ≥5, the temporary grid is divided into 4 small tiles; If the local complexity of the obtained temporary mesh is 2≤ If the local complexity of the temporary grid is less than 5, keep the original temporary grid size; If the local complexity of the temporary grid is greater than 5 If the local complexity of the temporary grid is less than 2, merge 4 adjacent temporary grids into 1 large tile.

[0010] Preferably, the dynamic resource assessment and selection specifically includes: When the sub-server starts, it sends a registration request to the master server through the TCP protocol, including static hardware information: CPU model / core number / main frequency, memory capacity / frequency, GPU model / video memory size, network adapter bandwidth, storage type; The master server assigns a unique ID to each node, establishes a node information library, and marks the node state as ready; The sub-server sends a heartbeat packet every 3 seconds, including dynamic indicators: CPU utilization, memory usage ratio, GPU utilization, network IO rate, current task queue length, and completion time of the last task; After calculating the weight of each node, filter out unavailable and high-load nodes, and then select the TopN nodes from the remaining nodes to form a target node pool.

[0011] Preferably, the dynamic task allocation and scheduling specifically includes: Construct a task package: Each task package contains: tile ID, tile coordinates, scene resource fragments, and rendering parameter verification rules; The task allocation strategy is as follows: Greedy allocation: Sort all tiles to be allocated in descending order of calculation weight Sort; Sort the target node pool by weight Sort in descending order; Assign the sorted tiles to the sorted nodes one by one, and the total calculation amount of each node allocated is ≤ the node load upper limit; Balanced allocation: Calculate the total calculation amount of all tiles to be allocated, and the total weight of the target node pool; The allocation upper limit of each node = (node weight ÷ total weight of the target node pool) × total calculation amount of all tiles to be allocated × 1.1.

[0012] Preferably, the task execution and process monitoring specifically includes: Sub-server task execution process: Resource loading: After receiving the task package, the sub-server loads the required scene resources through shared storage or P2P protocol, and preferentially caches frequently used texture and material data; Render execution: Call the local rendering engine to render the tile according to the parameters in the task package, and generate a temporary image file; Progress reporting: Every 10% of the rendering progress is completed, a progress report is sent to the main server, including tile ID, completed percentage, estimated remaining time, and current resource occupation.

[0013] Preferably, the method further comprises: Multi-dimensional monitoring mechanism: Heartbeat monitoring: The main server detects the heartbeat of the sub-server in real time, and if no heartbeat is received for more than 10 seconds, it is marked as a suspected failure; if no heartbeat is received for more than 20 seconds, it is marked as a failure; Progress monitoring: The main server sets a progress timeout threshold based on the estimated remaining time reported by the sub-server, and if a certain tile exceeds the threshold without being completed and the progress is not updated, it triggers an overtime warning; Resource monitoring: The sub-server monitors local resources in real time, and if CPU / GPU utilization is greater than or equal to 95% for 10 seconds or memory occupation is greater than or equal to 90%, it sends a resource shortage warning to the main server, which suspends the allocation of new tasks to the node.

[0014] Preferably, the method further comprises: Fault transfer and task retry: Fault node processing: After the main server marks a fault node, it immediately isolates the node and queries its unfinished tile tasks; Task reassignment rules: First, assign the unfinished tasks of the fault node to the node with the closest hardware configuration to the fault node; If the task has been executed for more than 50%, continue rendering from the breakpoint on the new node; otherwise, start rendering again; Retry limit: The same tile can be retried at most 3 times, and if all 3 attempts fail, adjust the splitting method of the tile and reassign it.

[0015] Preferably, the method further comprises: Result collection, verification and synthesis: Collect and verify the integrity and consistency of the tile rendering results, synthesize the complete image through edge blending algorithm and perform post-processing, finally deliver the results and release the related resources.

[0016] As described above, due to the adoption of the above technical solutions, the beneficial effects of the present application are: 1. The present application quantifies the complexity of geometry, material texture, and lighting effects into computational weight values by constructing a three-dimensional complexity evaluation model, providing a unified and scientific standard for task splitting, avoiding the traditional subjective experience-based fuzzy judgment; and combining with scene complexity variance to dynamically select the splitting mode: uniform splitting when the complexity difference is small, and adjusting the tile size according to local complexity when the difference is large, thus eliminating long-tail tasks from the root.

[0017] 2、The application can accurately capture task abnormalities through heartbeat, progress and resource three-dimensional monitoring; after a fault, the unfinished task is preferentially assigned to a node with similar hardware configuration; in the result processing link, MD5 check and tile integrity check are used to ensure data reliability; linear mixing or Gaussian blur transition is used for the overlapping edges of adjacent tiles to completely eliminate the splicing joint; and after unified post-processing such as color correction and non-local mean denoising, the output image has high precision and stable quality. BRIEF DESCRIPTION OF DRAWINGS

[0018] In the following description of exemplary embodiments in conjunction with the accompanying drawings, more details, features and advantages of the application are disclosed, in which: Figure 1 The method flowchart of the application. DETAILED DESCRIPTION

[0019] Several embodiments of the application will be described in more detail below with reference to the accompanying drawings, so that those skilled in the art can implement the application. The application can be embodied in many different forms and purposes and should not be limited to the embodiments described herein. These embodiments are provided to make the application comprehensive and complete, and to fully convey the scope of the application to those skilled in the art. The embodiments do not limit the application.

[0020] Unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs. It will be further understood that terms such as those defined in commonly used dictionaries should be interpreted as having a meaning consistent with their meaning in the context of the relevant art and / or the specification, and should not be interpreted in an idealized or overly formal sense, unless expressly so defined herein.

[0021] Embodiment 1 The detailed description is combined with the accompanying drawings Figure 1 will be described in detail.

[0022] The accompanying drawings Figure 1 The 3D visualization modeling method flowchart based on the Internet provided by the embodiment of the application shows the complete steps from task analysis and intelligent splitting to result collection, verification and synthesis.

[0023] In this embodiment, it includes: Task analysis and intelligent splitting: through the analysis of 3D rendering request and quantitative evaluation of scene complexity, the task is split into subtasks that are parallel, load balanced and have low communication overhead by using adaptive tile splitting strategy; Specifically, it includes: After the main server receives the user 3D rendering request, it first parses different types of scene files through the format adaptation module to extract core data: scene topology structure, asset reference path, rendering parameter set (resolution WxH, sampling rate S, anti-aliasing level A, output format PNG / EXR, etc.); A three-dimensional complexity evaluation model is constructed, and the calculation amount weight value of each scene is calculated by the following indexes . Geometric complexity : , unit: million surface equivalent, where is the number of vertices, is the number of triangles; Material texture complexity : , unit: hundred million pixel equivalent, plus a correction value of 0.1 times the number of complex shaders; Lighting and special effect complexity : . After presetting the weight factors of geometric complexity , material texture complexity , and lighting and special effect complexity , respectively, multiply them by the corresponding weight factors, and sum them up to get the calculation amount weight value .

[0024] A quantifiable three-dimensional scene complexity evaluation system is constructed, breaking through the limitations of traditional evaluation relying on subjective experience and lacking unified standards. It converts the complexity of geometry (number of vertices, number of triangles), material texture (resolution, channel number, compression ratio, and number of shaders), and lighting and special effects (various types of lighting and particle systems) into calculation amount weight values through explicit formulas, providing precise measurement basis for the calculation load of different scenes and different regions, and providing scientific support for subsequent task splitting, avoiding the imbalance of sub-task load caused by fuzzy complexity judgment, and ensuring the rationality and operability of distributed rendering from the source.

[0025] Adaptive tile splitting strategy, as follows: Basic rules: first determine the minimum tile size (such as 16x16 pixels to ensure parallel granularity) and the maximum tile size (such as 256x256 pixels to control communication overhead); When the scene complexity variance is ≤1.2 (i.e. the difference between the calculation amount weight values of each region is less than 20%), split by equal grid, with tile number (reserve redundancy for easy load adjustment); Adaptive non-uniform splitting process: The main server performs pre-sampling analysis on the scene, dividing the image into a temporary grid of 128×128 pixels, and calculates the local complexity of each temporary grid. ; If the local complexity of the obtained temporary mesh is When the value is ≥5, the temporary grid is divided into 4 small tiles; If the local complexity of the obtained temporary mesh is 2≤ When the value is less than 5, maintain the original temporary grid size; If the local complexity of the obtained temporary mesh is When the value is less than 2, merge 4 adjacent temporary grids into 1 large tile; Ensure that the computational complexity of all tiles differs by ≤15% to avoid any single tile becoming a long-tail task.

[0026] Adaptive tile splitting based on quantized complexity data solves the problems of overloaded subtasks in complex regions and wasted resources in simple regions when splitting tiles to a fixed size. It dynamically selects the splitting mode (uniform or non-uniform) by leveraging scene complexity variance, adjusts tile size according to local complexity thresholds (splitting high-complexity tiles into smaller ones and merging low-complexity tiles), and controls long-tail tasks by verifying computational differences of ≤15%. This reduces communication overhead while maintaining parallel granularity, achieving subtask load balancing and significantly improving the overall rendering efficiency and resource utilization of the cluster.

[0027] Dynamic resource assessment and selection: Based on the static hardware information and dynamic performance profile of the sub-server, the target node pool is selected and determined through weight calculation to achieve the initial matching of tasks and resources; Specifically, it includes: When the sub-server starts, it sends a registration request to the master server via TCP protocol, which includes static hardware information: CPU model / number of cores / clock speed, memory capacity / frequency, GPU model / video memory size (when GPU rendering is supported), network adapter bandwidth, and storage type (local SSD / shared storage). The master server assigns a unique ID to each node, establishes a node information database, and marks the node status as ready. The sub-server sends a heartbeat packet every 3 seconds, which includes dynamic metrics: CPU utilization (average over the last 3 seconds), memory usage percentage, GPU utilization (if enabled), network I / O rate (send / receive), current task queue length, and completion time of the most recent task. The main server updates the node performance profile every 5 seconds, using a sliding window weighted average (the most recent 10 reported data, with the weight decreasing over time) to avoid instantaneous fluctuations affecting the assessment. After calculating the weight of each node, filter out the unavailable and high-load nodes, then select the TopN (N = the number of task packages to be allocated) nodes with the highest weight from the remaining nodes to form the target node pool; ; Hardware performance score : CPU core number x frequency ÷ 3 + memory capacity (GB) x 0.5 + GPU performance score (preset by model, e.g. RTX3090 = 10 points, RTX4090 = 15 points); Load idle degree : 1 - current CPU utilization (decimal), if GPU rendering, take the minimum value of CPU and GPU utilization; Network quality : 1 - network delay (ms) between master and slave nodes ÷ 100 (Q ≥ 0 when delay ≤ 100ms, Q = 0 when delay > 100ms, exclude high-delay nodes).

[0028] A dynamic and multi-dimensional resource evaluation system is constructed, breaking through the limitations of traditional node selection relying only on static hardware parameters. It updates the node performance portrait through the heartbeat data (CPU utilization, memory usage, network IO, etc.) reported by the sub-servers in real time, combined with the sliding window weighted average algorithm, which can accurately capture the real-time state of the node, avoid resource mismatch problems such as overloading of high-performance nodes and idling of low-load nodes caused by static evaluation, and make resource selection more in line with actual running conditions.

[0029] Dynamic task allocation and scheduling: build task packages, select greedy or balanced allocation strategy according to the performance difference of cluster nodes, and manage the priority of the queue to ensure load balancing and efficiency; Specifically including: Building task packages: Each task package contains: tile ID, tile coordinates (left upper corner X / Y, width and height), scene resource fragments (only the geometry data, material texture, and lighting parameters required for this tile, transmitted through shared storage path or P2P), rendering parameters (consistent with user request, including timeout threshold), and verification rules (such as MD5 calculation seed); Task package size control: single task package data volume ≤ 100MB (to avoid long network transmission time), and use fragment packaging (fragment size ≤ 20MB) when exceeding; Task allocation strategy is as follows: Greedy allocation (priority to efficiency): Sort all tiles to be allocated in descending order according to the calculation weight (complex tiles first); Sort the target node pool in descending order according to the weight (high-performance nodes first); The sorted tiles are assigned to the sorted nodes in sequence. The total computational cost of the tiles assigned to each node is less than or equal to the node's load limit (the node's hardware performance is divided into H×2 to avoid overloading a single node). Balanced distribution (prioritizing fairness): Calculate the total computational cost for all tiles to be assigned (all) The sum of all, the total weight of the target node pool (all) sum); The maximum allocation per node = (node ​​weight) (÷ Total weight of the target node pool) × Total computational cost of all tiles to be allocated × 1.1 (10% flexibility reserved); Sub-server local maintenance priority queue: sorted by task allocation time by default, supports emergency task skipping (tasks marked as urgent by users have priority +3) and long-tail task acceleration (tasks that have been executed more than 50% of the estimated time have priority +1). The tiles are allocated cyclically. Each time, the node with the largest difference between the currently allocated computational load and the upper limit is selected, and the tile with the closest computational load to that difference is allocated from the remaining tiles, until all tiles are allocated.

[0030] By employing a refined task package construction and dual-mode allocation strategy, this approach addresses the issues of resource waste and poor adaptability in traditional task allocation. The constructed task packages contain only the core resources required for tile rendering (geometric data, material textures, etc.), and each package is controlled to be ≤100MB (fragmentation is used when exceeding this limit), significantly reducing network data transmission and communication overhead. Simultaneously, the allocation strategy dynamically switches based on the performance differences of cluster nodes: when node performance varies greatly, greedy allocation (complex tasks are prioritized for high-performance nodes) ensures efficiency; when node performance is similar, balanced allocation (tasks are distributed according to weighted proportions) avoids load imbalance, allowing task allocation to accurately adapt to different cluster scenarios and improving overall scheduling rationality.

[0031] By further optimizing task execution efficiency through queue priority management, the limitations of traditional single queues, such as delays in urgent tasks and congestion in long-tail tasks, are overcome. The local queue of the sub-server supports emergency task skipping (priority +3) and long-tail task acceleration (priority +1), which can prioritize responding to high-priority business needs while avoiding individual tasks slowing down the overall progress. The main server also monitors the node queue length. When a node queue is congested and there are idle nodes, low-priority tiles are migrated to ensure load balancing across nodes, thus guaranteeing the smoothness and responsiveness of distributed rendering from the scheduling level.

[0032] Task execution and process monitoring: The sub-server executes 3D rendering tasks and reports progress. The main server tracks the task status through multi-dimensional monitoring and handles anomalies with the help of a failover mechanism to ensure reliable task execution. Specifically, it includes: Sub-server task execution flow: Resource loading: After receiving the task package, the sub-server loads the required scene resources through shared storage (such as NFS / S3) or P2P protocol, and preferentially caches high-frequency texture and material data (cache validity period of 30 minutes); Rendering execution: Call the local rendering engine to render the tile according to the parameters in the task package, and generate a temporary image file (RAW format, maximum precision retained); Progress reporting: Every 10% of the rendering progress is completed, a progress report is sent to the main server, including tile ID, completed percentage, estimated remaining time, and current resource usage (CPU / GPU / memory).

[0033] Multi-dimensional monitoring mechanism: Heartbeat monitoring: The main server detects the heartbeat of the sub-server in real time, and if no heartbeat is received for more than 10 seconds (default threshold, which can be adjusted according to network quality), it is marked as suspected failure; if no heartbeat is received for more than 20 seconds, it is marked as failure; Progress monitoring: The main server sets a progress timeout threshold based on the estimated remaining time reported by the sub-server (estimated remaining time x 1.5), and if a tile exceeds this threshold without completing and updating the progress, it triggers an overtime warning; Resource monitoring: The sub-server monitors local resources in real time, and if CPU / GPU utilization is continuously ≥95% for 10 seconds or memory usage is ≥90%, it sends a resource shortage warning to the main server, which temporarily suspends assigning new tasks to the node.

[0034] 8. The Internet-based 3D visualization modeling method according to claim 7, further comprising: Fault transfer and task retry: Fault node processing: After marking the fault node, the main server immediately isolates the node (no new tasks are assigned) and queries its unfinished tile tasks; Task reassignment rules: Preferentially assign the unfinished tasks of the fault node to the node closest to the fault node in terms of hardware configuration (to reduce resource adaptation cost); If the task has been executed for more than 50%, continue rendering from the breakpoint on the new node (through the breakpoint resume function of the rendering engine); otherwise, start rendering again.

[0035] Retry limit: The same tile can be retried at most 3 times, and if all 3 times fail, adjust the splitting method of the tile (such as splitting it into smaller tiles) and then reassign it.

[0036] Result collection, verification and synthesis: Collect and verify the integrity and consistency of the tile rendering results, synthesize the complete image through the edge blending algorithm, perform post-processing, and finally deliver the results and release the related resources, including: Asynchronous result uploading and storage: After the tile rendering is completed, the sub-server first compresses the RAW format image (EXR format preserves high precision, and PNG format is used for fast preview), and then uploads it asynchronously to the specified storage directory of the main server through the HTTP / 2 protocol; Support for resuming transmission: If the network is interrupted during uploading, continue transmission from the uploaded progress after the connection is restored to avoid repeated uploading.

[0037] Storage organization: Create an independent directory according to the task ID, and the tile file naming rule is Tile ID_Node ID_Time Stamp. Format, which is convenient for tracing and management; Data integrity and consistency verification: Checksum verification: The sub-server calculates the MD5 value of the tile file and uploads it with the file; the main server recalculates the MD5 value after receiving it and compares it with the uploaded value. If they are consistent, it is confirmed that the reception is successful, and if they are not consistent, it is required to upload again.

[0038] Tile integrity check: The main server checks whether the received tile ID matches the tile list when splitting, and if it is missing, it is marked as incomplete, triggering the reassignment of the tile.

[0039] Format consistency verification: Check whether the resolution, color space, and channel number of all tiles are uniform to avoid format conflicts during synthesis; The main server arranges the tiles in the order from left to right and top to bottom according to the X / Y coordinates of each tile to construct the pixel matrix of the complete image.

[0040] Edge blending algorithm: Linear blending is used for the overlapping edges (default 2-4 pixels) of adjacent tiles to calculate the average RGB value of the edge pixels and eliminate the splicing joint; Gaussian blur transition is used for complex scenes (such as high-contrast areas) with a blending radius = edge pixel number x 0.5.

[0041] Uniform post-processing: Perform batch processing on the complete image after synthesis according to the user's requested parameters: Color correction: Adjust brightness / contrast / saturation (parameter range ±10% to avoid excessive correction); Noise reduction: For high sampling rate rendering results, use non-local mean noise reduction algorithm to preserve details while reducing noise; Format conversion: Convert the processed image to the user-specified output format (such as PNG, JPG, EXR).

[0042] The main server returns the final image to the user through the CDN acceleration (supporting breakpoint download), and sends a task completion notification (including rendering time consumption, node usage, result preview link) to the user.

[0043] Resource release: automatically delete temporary tile files, cached scene resources (if no similar task within 30 minutes), sub-server releases CPU / GPU / memory resources occupied by the task, and restores to idle state, waiting for new task allocation.

[0044] The above formulas are dimensionless values calculated, and the formulas are obtained by collecting a large amount of data to simulate a formula of the latest real situation, and the preset parameters in the formula are set by the person skilled in the art according to the actual situation.

[0045] The above only describes some exemplary embodiments of the present application in a descriptive manner, and it is needless to say that those skilled in the art can modify the described embodiments in various ways without departing from the spirit and scope of the present application. Therefore, the above drawings and descriptions are illustrative in nature and should not be understood as limiting the scope of protection of the claims of the present application.

[0046] It should be noted that in this paper, if there are relationship terms such as first and second, they are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between the entities or operations. Moreover, the terms "include", "contain" or any other variants thereof are intended to cover non-exclusive inclusion, so that the process, method, article or equipment including a series of elements not only includes those elements, but also includes other elements not explicitly listed or inherent to such process, method, article or equipment. Without more limitations, the element defined by the statement "including a" does not exclude the presence of other identical elements in the process, method, article or equipment including the element.

[0047] It should be understood that in various embodiments of the present application, the size of the sequence number of each process does not mean the order of execution, and the execution order of each process should be determined by its function and inherent logic, and should not constitute any limitation on the implementation process of the embodiments of the present application.

[0048] Those skilled in the art can clearly understand that the units and algorithm steps of each example described in combination with the embodiments disclosed herein can be realized by electronic hardware or a combination of computer software and electronic hardware. Whether the functions are realized in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of the present application.

[0049] Those skilled in the art can clearly understand that, for the convenience and brevity of the description, the specific working processes of the above-described system, device and unit can refer to the corresponding processes in the foregoing method embodiments, which will not be described here.

[0050] The units described as separate components can or can not be physically separated, and the components shown as units can or can not be physical units, i.e. they can be located in one place or distributed on multiple network units. Part or all of the units can be selected to achieve the purpose of the embodiment according to actual needs.

[0051] In addition, the functional units in each embodiment of the present application can be integrated into one processing unit, or each unit can be physically present separately, or two or more units can be integrated into one unit.

[0052] The above is only a specific implementation of the present application, but the protection scope of the present application is not limited thereto. Any skilled person in the art can easily think of changes or replacements within the technical scope disclosed in the present application, which should be covered within the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.

[0053] The above only describes some exemplary embodiments of the present application by way of illustration, and it is needless to say that those skilled in the art can modify the described embodiments in various ways without deviating from the spirit and scope of the present application. Therefore, the above figures and descriptions are illustrative in nature and should not be understood as limiting the scope of protection of the claims of the present application.

Claims

1. A 3D visualization modeling method based on the Internet, characterized in that, include: Task analysis and intelligent splitting: By analyzing 3D rendering requests and quantitatively assessing scene complexity, an adaptive tile splitting strategy is adopted to split tasks into parallel, load-balanced, and low-communication-overhead subtasks. Dynamic resource assessment and selection: Based on the static hardware information and dynamic performance profile of the sub-server, the target node pool is selected and determined through weight calculation to achieve the initial matching of tasks and resources; Dynamic task allocation and scheduling: Construct task packages, allocate tasks based on the performance differences of cluster nodes using either a greedy or balanced allocation strategy, and ensure load balancing and efficiency through queue priority management; Task execution and process monitoring: The sub-server executes 3D rendering tasks and reports progress. The main server tracks the task status through multi-dimensional monitoring and handles anomalies with the help of a failover mechanism to ensure reliable task execution.

2. The Internet-based 3D visualization modeling method according to claim 1, characterized in that, Task analysis and intelligent breakdown specifically include: After receiving a user's 3D rendering request, the main server first parses different types of scene files through the format adaptation module and extracts the scene topology, asset reference path, and rendering parameter set. Construct a three-dimensional complexity evaluation model, using geometric complexity. Material texture complexity Complexity of lighting effects Calculate the computational weight value for each scenario. ; Preset geometric complexity respectively Material texture complexity Complexity of lighting effects After determining the weighting factors, each weight is multiplied by its corresponding weighting factor, and the results are summed to obtain the calculated weight value. .

3. The Internet-based 3D visualization modeling method according to claim 2, characterized in that, It also includes an adaptive tile splitting strategy, as follows: Basic rule: First determine the minimum and maximum tile sizes; When the scene complexity variance is ≤1.2, the number of tiles is determined by equal grid splitting. ; Adaptive non-uniform splitting process: The main server performs pre-sampling analysis on the scene, dividing the image into a temporary grid of 128×128 pixels, and calculates the local complexity of each temporary grid. ; If the local complexity of the obtained temporary mesh is When the value is ≥5, the temporary grid is divided into 4 small tiles; If the local complexity of the obtained temporary mesh is 2≤ When the value is less than 5, maintain the original temporary grid size; If the local complexity of the obtained temporary mesh is When the value is less than 2, four adjacent temporary grids are merged into one large tile.

4. The Internet-based 3D visualization modeling method according to claim 1, characterized in that, Dynamic resource assessment and selection specifically includes: When the sub-server starts, it sends a registration request to the master server via TCP protocol, which includes static hardware information: CPU model / number of cores / clock speed, memory capacity / frequency, GPU model / video memory size, network adapter bandwidth, and storage type. The master server assigns a unique ID to each node, establishes a node information database, and marks the node status as ready. The sub-server sends a heartbeat packet every 3 seconds, which includes dynamic metrics: CPU utilization, memory usage percentage, GPU utilization, network I / O rate, current task queue length, and completion time of the most recent task. After calculating the weight of each node, unavailable and high-load nodes are first filtered out, and then the top N nodes with the highest weights are selected from the remaining nodes to form the target node pool.

5. The Internet-based 3D visualization modeling method according to claim 1, characterized in that, Dynamic task allocation and scheduling, specifically including: Build the task package: Each task package contains: tile ID, tile coordinates, scene resource fragments, and rendering parameter verification rules; The task allocation strategy is as follows: Greedy allocation: All tiles to be assigned are weighted according to their calculated quantity. Sort in descending order; Weighted distribution of the target node pool Sort in descending order; The sorted tiles are assigned to the sorted nodes in sequence, and the total computational cost of the tiles assigned to each node is less than or equal to the node's load limit. Balanced distribution: Calculate the total computational cost of all tiles to be assigned and the total weight of the target node pool; The maximum allocation per node = (node ​​weight) (÷ Total weight of the target node pool) × Total computational cost of all tiles to be allocated × 1.

1.

6. The Internet-based 3D visualization modeling method according to claim 1, characterized in that, Task execution and process monitoring, specifically including: Sub-server task execution flow: Resource loading: After receiving the task package, the sub-server loads the required scene resources through shared storage or P2P protocol, prioritizing the caching of frequently used texture and material data; Rendering execution: Invoke the local rendering engine, render the tiles according to the parameters in the task package, and generate temporary image files; Progress reporting: Send a progress report to the main server every time 10% of the rendering progress is completed, including tile ID, percentage completed, estimated remaining time, and current resource usage.

7. The Internet-based 3D visualization modeling method according to claim 6, characterized in that, Also includes: Multi-dimensional monitoring mechanism: Heartbeat monitoring: The main server monitors the heartbeat of the sub-servers in real time. If no heartbeat is received for more than 10 seconds, it is marked as a suspected fault. A time exceeding 20 seconds is marked as a fault; Progress monitoring: The master server sets a progress timeout threshold based on the estimated remaining time reported by the sub-server. If a tile exceeds the threshold and is not completed and the progress is not updated, a timeout warning is triggered. Resource monitoring: The sub-server monitors local resources in real time. If the CPU / GPU utilization is ≥95% for 10 seconds or the memory usage is ≥90%, it sends a resource shortage warning to the master server, and the master server suspends the allocation of new tasks to that node.

8. The Internet-based 3D visualization modeling method according to claim 7, characterized in that, Also includes: Failover and task retry: Failure Node Handling: After the master server marks a failure node, it immediately isolates the node and queries its unfinished tile tasks; Task reallocation rules: Prioritize assigning unfinished tasks from the faulty node to the node with the closest hardware configuration to the faulty node; If the task has been completed more than 50%, resume rendering from the breakpoint on the new node; otherwise, restart rendering. Retry limit: The same tile can be retried a maximum of 3 times. If all 3 attempts fail, the tile will be reassigned after the splitting method is adjusted.

9. The Internet-based 3D visualization modeling method according to claim 1, characterized in that, Also includes: Results collection, verification and synthesis: Collect and verify the integrity and consistency of tile rendering results, synthesize complete images through edge blending algorithms and perform post-processing, finally deliver the results and release related resources.

Images