Object rendering method and device, equipment, medium and product

Abstract

The embodiment of the invention provides an object rendering method and device, equipment, a medium and a product. The object rendering method comprises the steps of obtaining a to-be-rendered picture, height information of the to-be-rendered picture and an object distribution mark; determining at least one object distribution area of the target object in the to-be-rendered picture based on the object distribution mark; generating a two-dimensional point cloud cluster in each object distribution area, determining the height of each point in the two-dimensional point cloud cluster based on the height information, and obtaining a three-dimensional point cloud cluster in each object distribution area; and based on the three-dimensional point cloud cluster in each object distribution area, generating a target grid of each object distribution area, and based on the target grid of each object distribution area, rendering a target object in the to-be-rendered picture. According to the scheme, the point cloud is generated in the two-dimensional distribution area and mapped to the surface height of the object, so that the number of particles and the calculation overhead are remarkably reduced, meanwhile, the texture and random distribution of natural particles are reserved, and the efficient and visual real rendering effect is achieved.

Description

Technical Field

[0001] The embodiments in this specification relate to the field of computer modeling technology, and in particular to an object rendering method, apparatus, device, medium, and product. Background Technology

[0002] With the rapid development of 3D games and virtual reality (VR) technology, the requirements for the simulation of natural environments are increasing, especially for the simulation of natural phenomena such as snow accumulation, which has raised the bar for realism.

[0003] To realistically recreate natural phenomena in scenes, two main technical approaches are currently employed: heightmap fluid simulation and particle system simulation. Heightmap fluid simulation uses two-dimensional heightmaps to describe the spatial distribution and thickness variations of natural phenomena (such as water, snow, and sand), and efficiently simulates their accumulation patterns based on fluid dynamics principles. However, natural phenomena generated by heightmap fluid simulation are often too regular and smooth, failing to meet the demands for high-realism visuals. Particle system simulation, on the other hand, uses a large number of particles to describe the three-dimensional distribution of natural phenomena, presenting a more natural, random, and three-dimensional visual effect, resulting in greater visual realism. However, this method requires real-time simulation of a large number of particles, leading to extremely high computational complexity and often requiring significant CPU (Central Processing Unit) resources, making it difficult to run in real-time on large-scale scenes and resulting in low overall processing efficiency.

[0004] Therefore, there is an urgent need for a method to simulate stacked objects that can reduce computational complexity and improve visual quality, in order to meet the pressing need for realistic simulation of natural phenomena in 3D games and virtual reality scenes. Summary of the Invention

[0005] In view of this, embodiments of this specification provide an object rendering method. One or more embodiments of this specification also relate to an object rendering apparatus, a computing device, a computer-readable storage medium, and a computer program product, to address the technical deficiencies existing in the prior art.

[0006] According to a first aspect of the embodiments of this specification, an object rendering method is provided, the method comprising:

[0007] Obtain the image to be rendered, its height information, and object distribution markers;

[0008] Based on object distribution markers, at least one object distribution region of the target object is determined in the image to be rendered;

[0009] Two-dimensional point cloud clusters are generated within the distribution area of ​​each object, and the height of each point in the two-dimensional point cloud cluster is determined based on the height information to obtain three-dimensional point cloud clusters within the distribution area of ​​each object.

[0010] Based on the 3D point cloud clusters within each object distribution area, a target mesh for each object distribution area is generated, and the target object is rendered in the image to be rendered based on the target mesh of each object distribution area.

[0011] According to a second aspect of the embodiments of this specification, an object rendering apparatus is provided, the apparatus comprising:

[0012] The acquisition module is configured to acquire the image to be rendered, the height information of the image to be rendered, and object distribution markers;

[0013] The determination module is configured to determine at least one object distribution region of the target object in the image to be rendered based on object distribution markers.

[0014] The first generation module is configured to generate two-dimensional point cloud clusters within each object distribution area, and determine the height of each point in the two-dimensional point cloud cluster based on the height information, thereby obtaining three-dimensional point cloud clusters within each object distribution area.

[0015] The second generation module is configured to generate target meshes for each object distribution area based on the 3D point cloud clusters within each object distribution area, and to render the target objects in the rendering screen based on the target meshes for each object distribution area.

[0016] According to a third aspect of the embodiments of this specification, a computing device is provided, comprising:

[0017] Memory and processor;

[0018] The memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions, which, when executed by the processor, implement the steps of the object rendering method described above.

[0019] According to a fourth aspect of the embodiments of this specification, a computer-readable storage medium is provided that stores computer-executable instructions that, when executed by a processor, implement the steps of the object rendering method described above.

[0020] According to a fifth aspect of the embodiments of this specification, a computer program product is provided, including a computer program / instructions that, when executed by a processor, implement the steps of the object rendering method described above.

[0021] This specification provides an embodiment of an object rendering method, which includes: acquiring a scene to be rendered, height information of the scene to be rendered, and object distribution markers; determining at least one object distribution region of the target object in the scene to be rendered based on the object distribution markers; generating two-dimensional point cloud clusters in each object distribution region, and determining the height of each point in the two-dimensional point cloud cluster based on the height information to obtain three-dimensional point cloud clusters in each object distribution region; generating target meshes for each object distribution region based on the three-dimensional point cloud clusters in each object distribution region, and rendering the target object in the scene to be rendered based on the target meshes of each object distribution region. This solution effectively avoids the high computational overhead caused by filling a large number of particles in three-dimensional space in traditional particle systems by generating particle point clouds in two-dimensional object distribution regions and mapping each particle to the surface height layer of the target object using height information. Simultaneously, these three-dimensional particle point clouds placed on a realistic height layer possess natural grain texture and random distribution characteristics, making the rendered object surface more three-dimensional and realistic, thus significantly improving visual realism while maintaining rendering efficiency. Attached Figure Description

[0022] Figure 1 This is a flowchart illustrating an object rendering method provided in one embodiment of this specification;

[0023] Figure 2 This is a schematic diagram of a height map provided in one embodiment of this specification;

[0024] Figure 3 This is a schematic diagram of a marking diagram provided in one embodiment of this specification;

[0025] Figure 4 This is a flowchart illustrating the processing of a FloodFill algorithm provided in one embodiment of this specification;

[0026] Figure 5 This is a flowchart of a point cloud generation algorithm provided in one embodiment of this specification;

[0027] Figure 6 This is a flowchart of a cluster connectivity optimization algorithm provided in one embodiment of this specification;

[0028] Figure 7 This is a flowchart of a grid splitting algorithm provided in one embodiment of this specification;

[0029] Figure 8 This is a flowchart of a mesh generation algorithm provided in one embodiment of this specification;

[0030] Figure 9 This is an architecture diagram of a GPU-accelerated implementation provided in one embodiment of this specification;

[0031] Figure 10 This is a flowchart illustrating the processing procedure of an object rendering method provided in one embodiment of this specification;

[0032] Figure 11 This is a schematic diagram of the structure of an object rendering apparatus provided in one embodiment of this specification;

[0033] Figure 12 This is a structural block diagram of a computing device provided in one embodiment of this specification. Detailed Implementation

[0034] Many specific details are set forth in the following description to provide a full understanding of this specification. However, this specification can be implemented in many other ways than those described herein, and those skilled in the art can make similar extensions without departing from the spirit of this specification. Therefore, this specification is not limited to the specific implementations disclosed below.

[0035] The terminology used in one or more embodiments of this specification is for the purpose of describing particular embodiments only and is not intended to be limiting of the one or more embodiments of this specification. The singular forms “a” and “the” as used in one or more embodiments of this specification and the appended claims are also intended to include the plural forms, unless the context clearly indicates otherwise. It should also be understood that the term “and / or” as used in one or more embodiments of this specification refers to and includes any or all possible combinations of one or more associated listed items.

[0036] It should be understood that although the terms first, second, etc., may be used to describe various information in one or more embodiments of this specification, such information should not be limited to these terms. These terms are only used to distinguish information of the same type from one another. For example, first may also be referred to as second without departing from the scope of one or more embodiments of this specification, and similarly, second may also be referred to as first. Depending on the context, the word "if" as used herein may be interpreted as "when," "when," or "in response to a determination."

[0037] Furthermore, it should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in one or more embodiments of this specification are all information and data authorized by the user or fully authorized by all parties. Moreover, the collection, use and processing of related data must comply with the relevant laws, regulations and standards of the relevant countries and regions, and corresponding operation entry points are provided for users to choose to authorize or refuse.

[0038] First, the terms and concepts used in one or more embodiments of this specification will be explained.

[0039] Depth-First Search (DFS) is an algorithm used to traverse or search graph or tree data structures. It explores the branches of the graph as "deeply" as possible, and only after all the child nodes of a node have been visited will the algorithm backtrack to the previous node and continue exploring other unvisited nodes.

[0040] Breadth-First Search (BFS) is an algorithm for traversing or searching a graph or tree. It starts from the initial node, visits all adjacent nodes, and then expands outwards layer by layer until the target is found or all nodes have been traversed.

[0041] FloodFill is a classic image processing and computer graphics algorithm used to find all connected pixels that satisfy specific conditions (usually the same color or pixel value) starting from a given starting pixel, and then perform uniform operations on these pixels (such as changing their color or assigning them numbers). Like a flood spreading from its starting point, FloodFill recursively (or iteratively) expands outwards until it can no longer spread, hence the name "Flood Fill".

[0042] This specification provides an object rendering method, and also relates to an object rendering apparatus, a computing device, a computer-readable storage medium, and a computer program product, which will be described in detail in the following embodiments.

[0043] See Figure 1 , Figure 1 A flowchart of an object rendering method according to an embodiment of this specification is shown, which specifically includes the following steps.

[0044] Step 102: Obtain the image to be rendered, the height information of the image to be rendered, and the object distribution markers.

[0045] The height information describes the position of the scene's surface (and sometimes large fixed structures) in the rendering image in the vertical direction (usually the Y-axis). It defines the undulations of the terrain, mountains, valleys, caves, building foundations, and other three-dimensional shapes.

[0046] The types of height information for the image to be rendered include, but are not limited to, the following:

[0047] (1) Height Map: A two-dimensional grayscale image. The pixel value of each pixel in the image represents the height value of a sampling point in the scene. The higher the brightness (white), the higher the height is usually represented; the lower the brightness (black), the lower the height is represented.

[0048] Figure 2 This is a schematic diagram of a height map provided in an embodiment of this specification. For example... Figure 2 As shown, each pixel represents a sampling point (grid point) on the ground of the scene. The gray value of a pixel (0-255) represents the height of that point: the brighter the color, the higher the height; the darker the color, the lower the height.

[0049] (2) Terrain file: A two-dimensional array is used to record the height value of each grid point (corresponding to a fixed position on a terrain plane).

[0050] The types of object distribution markers for the target object in the image to be rendered include, but are not limited to, the following:

[0051] (1) Flag Map: A binary or multi-valued two-dimensional image where the position of each pixel corresponds to a geographic coordinate point in the scene, and the gray value of the pixel is used to encode the distribution state of the target object at that location. For example, the gray value can indicate whether an object exists (0 = no object, 255 = object), or indicate the object density / intensity.

[0052] Figure 3 This is a schematic diagram of a marking diagram provided in an embodiment of this specification. For example... Figure 3 As shown, the marker map is normalized to a floating-point range of 0 to 1. In this marker map, each pixel value is used to indicate whether there is snow at the corresponding location in the scene: when the pixel value is 1 (pure white), it means that there is snow at that location; when the pixel value is 0 (pure black), it means that there is no snow at that location.

[0053] In actual implementation, when the height information of the image to be rendered is the height map of the image to be rendered, edge detection can be performed on the height map to detect boundaries with drastic height changes, and these edge positions can be marked to form a marker map.

[0054] (2) Tag file: The file lists the distribution coordinates of the target object.

[0055] In this context, an "object" in the rendered image is an independently identifiable, manageable entity or effect unit within the scene that ultimately produces pixels. It possesses the geometric, material, and spatial information required for rendering. Examples include snow, sand dunes, and layers of fallen leaves.

[0056] Step 104: Determine at least one object distribution area of ​​the target object in the image to be rendered based on the object distribution markers.

[0057] It should be noted that the object distribution markers obtained in step S102 only mark the distribution location of the objects, but cannot intuitively display the distribution area of ​​the objects. In order to render the target object in the screen to be rendered, the object distribution markers need to be further processed to obtain at least one object distribution area of ​​the target object in the screen to be rendered.

[0058] In one optional implementation of this embodiment, the object distribution marker is a marker map of the target object. Based on the object distribution marker, at least one object distribution region of the target object in the image to be rendered is determined, specifically including the following steps:

[0059] The process begins by identifying the first pixel in the marker image whose value is the target value. Then, it determines the corresponding first object distribution area, starting from this first pixel. The target value indicates the presence of a target object at the corresponding pixel in the marker image. The process then updates the pixel values ​​of each pixel within the first object distribution area in the marker image. Finally, it returns to the previous steps of identifying the first pixel in the marker image whose value is the target value and determining the corresponding first object distribution area, continuing until no pixel in the marker image has the target value. This process yields the object distribution areas in the image to be rendered.

[0060] It should be understood that the above scheme is used to extract independent distribution regions of target objects (such as snow) from a binary labeled map. The core idea of ​​this scheme is to traverse the labeled map, perform seed filling (region growing) on ​​each unprocessed pixel representing the target object, find all connected pixel sets (i.e., an object distribution region), and mark them as processed, until there are no unprocessed target pixels in the map.

[0061] Specifically, the input is a binary labeled image where a pixel value equals the target value (e.g., pixel value = 1): indicating that a target object (such as snow) exists at that pixel location. A pixel value ≠ the target value (e.g., pixel value = 0): indicating that a target object does not exist at that location or that it belongs to another object / background.

[0062] process:

[0063] Step 1: Traverse the marker map in a certain order (usually row-first scan) to find the first unprocessed pixel with the target value (the first pixel).

[0064] Step 2: Using the first pixel as the seed point (starting point), execute a region growing algorithm (such as Depth-First Search (DFS) or Breadth-First Search (BFS)) to find all pixels connected to the first pixel (usually a 4-neighborhood or an 8-neighborhood) with a pixel value equal to the target value. These points together constitute an object distribution region (the first object distribution region).

[0065] Step 3: Update the pixel values ​​of all pixels within this region (the first object distribution region) to a new, specific value. This new value indicates that the pixel belongs to an already identified object distribution region, and that the pixel has been processed to avoid being treated as a new seed point in subsequent steps. If it is necessary to distinguish between different regions later, the new value can be a unique region ID.

[0066] Step 4: Return to Step 1 and continue scanning the remaining pixels in the image whose pixel values ​​are still the original target values ​​(i.e., not updated in Step 3) to find the next seed point (the first pixel).

[0067] Loop termination condition: The loop ends when no more pixels with the original target value can be found after scanning the entire image.

[0068] Output: The marker map itself is modified, where all pixels that were originally the target value are now assigned new values ​​representing their respective regions. Simultaneously, the algorithm internally records the number of regions found and the set of pixels (location information) contained in each region.

[0069] For example, suppose we have the following binary labeled image, where pixel values ​​are represented by numbers:

[0070]

[0071] Where: 1 represents the target value (e.g., snow cover), and 0 represents the background.

[0072] The execution process is as follows:

[0073] Step 1: Scan to find the first target pixel

[0074] Scan by row priority:

[0075] Find the first target pixel value = 1 in (0,2) and set it as P_start(first pixel value).

[0076] Step 2: Region growing (using DFS or BFS)

[0077] Starting from (0,2), use DFS / BFS to find all pixels connected to it with a value of 1.

[0078] Assume we use a 4-neighborhood (top, bottom, left, and right).

[0079] Growth results in region 1:

[0080] Starting point: (0,2)

[0081] Connected pixels include:

[0082] (0,2)->(1,2)->(1,1)

[0083] Region 1 contains the following pixels: {(0,2),(1,2),(1,1)}

[0084] Step 3: Update pixel values

[0085] Update the pixel value of region 1 from 1 to 0.1 (indicating that this is the first region to be identified).

[0086] Updated image:

[0087]

[0088] Step 4: Continue scanning

[0089] Continue row-priority scanning, skipping pixels that have already been processed (whose value has become 0.1).

[0090] Find the next pixel with a value of 1, which is at (2,4), and set it as P_start_next.

[0091] Region 2 growth: Starting from (2,4), find all pixels connected to it: (2,4)->(3,4)->(3,3); The pixels contained in region 2 are: {(2,4),(3,4),(3,3)}; Update pixel values: Update these pixel values ​​from 1 to 0.2 (second region).

[0092] Updated image:

[0093]

[0094] Check if the loop has terminated. Continue scanning: If no more pixels have a value of 1 (original target value), end.

[0095] Output the final labeled image:

[0096]

[0097] Where 0.1 indicates that it belongs to object distribution region 1, and 0.2 indicates that it belongs to object distribution region 2.

[0098] Regional statistics: A total of 2 target regions were detected.

[0099] Object distribution region 1: {(0,2),(1,2),(1,1)}; Object distribution region 2: {(2,4),(3,4),(3,3)}.

[0100] Thus, the process of determining at least one object distribution area of ​​the target object in the image to be rendered is completed based on the input marker map.

[0101] The above embodiments use DFS or BFS-based region growing algorithms to detect and number connected components in the labeled graph. This can accurately segment all connected target regions and assign them independent labels, avoiding repeated scanning and significantly improving processing efficiency. At the same time, it can directly count the number of targets and the pixel information of each region, providing a good foundation for further rendering of target objects.

[0102] In an optional implementation of this embodiment, determining the corresponding first object distribution area starting from the first pixel point specifically includes the following steps: retrieving the second pixel point from the target queue corresponding to the first pixel point, wherein the target queue corresponding to the first pixel point is used to store the pixel points found starting from the first pixel point, and the second pixel point is the pixel point currently to be processed in the target queue; determining at least one third pixel point with a pixel value of the target value among the neighboring points of the second pixel point, adding the third pixel point to the queue, and returning to execute the step of retrieving the second pixel point from the target queue corresponding to the first pixel point until the target queue is empty, thereby obtaining the first object distribution area corresponding to the first pixel point.

[0103] It should be noted that this embodiment provides a queue-based (BFS-style) region growth process. The specific scheme is as follows:

[0104] Input: Binary labeled image (target value = target object exists)

[0105] Process: Find the first target value pixel (first pixel) as the seed and create a dedicated queue for that seed (target queue). Process the queue iteratively: Take a pixel from the queue (second pixel) and check its neighboring pixels (third pixel). If a neighboring pixel is the target value, add it to the queue; when the queue is empty, region growth is complete. Output: Connected region (first object distribution region).

[0106] For example, suppose we have the following binary labeled image, where pixel values ​​are represented by numbers:

[0107]

[0108] Detailed process

[0109] Step 1: Find the first target pixel (first pixel).

[0110] Line-first scanning: The first pixel with a value of 1 is found at position (0,2), and it is set as the first pixel (seed).

[0111] Step 2: Create a dedicated queue (target queue) for this seed.

[0112] Initialize queue Q = [(0,2)] and update the pixel value at position (0,2) in the marker graph to 0.5.

[0113] Step 3: Process the queue in a loop.

[0114] Take out the pixel (second pixel) from the queue: queue head current = (0,2); check its neighboring pixels (third pixel): assuming 4 neighbors (top, bottom, left, right), for the neighbor of (0,2): (1,2) value = 1, which meets the target value, add it to the queue, and update the pixel value at position (1,2) in the marker graph to 0.5. Other neighbors are not the target value or are out of bounds.

[0115] Update the queue: Queue Q = [(1,2)].

[0116] Then retrieve the pixel from the queue: current = (1,2); check the neighborhood: (1,1) value = 1, add it to the queue, and update the pixel value at position (1,1) in the marker image to 0.5.

[0117] Update the queue: Queue Q = [(1,1)].

[0118] Continue the loop:

[0119] Then retrieve the pixel from the queue: current = (1,1); check the neighborhood: (0,1), (1,0), (2,1), (1,2) are not the target value; the queue is empty, Q = [], and the loop ends.

[0120] Output: Connected region (first object distribution region)

[0121] The region contains the following pixels: {(0,2),(1,2),(1,1)}

[0122] After marking on the original image, we can obtain:

[0123]

[0124] Here, 0.5 indicates that the area has been identified as the first object distribution area.

[0125] The above embodiments start from the first target pixel, use a queue to efficiently grow complete connected regions, automatically extract all interconnected target pixels and avoid redundant processing, which not only ensures the integrity and accuracy of region detection, but also significantly improves computational efficiency.

[0126] In one optional implementation of this embodiment, the process of obtaining the first object distribution region corresponding to the first pixel point until the target queue is empty specifically includes the following steps: obtaining the candidate object distribution region corresponding to the first pixel point until the target queue is empty; determining the number of pixels in the candidate object distribution region; and determining the candidate object distribution region as the first object distribution region corresponding to the first pixel point if the number of pixels is greater than the pixel threshold.

[0127] It should be noted that in the optional implementation of this scheme, after completing the region growing, the following step is introduced: counting the number of pixels in the candidate region (i.e., the "area" of the region). If this number is greater than a pixel threshold, it is determined as a true object region (the first object distribution region corresponding to the first pixel). Otherwise, the region is considered too small, possibly noise or a pseudo-connected component, and is not processed as a valid object.

[0128] During image segmentation, some very small regions may appear. These regions are often caused by noise, uneven lighting, or minor errors in image acquisition and usually lack practical analytical significance. To improve overall processing efficiency and the accuracy of segmentation results, an area threshold is typically set to filter regions smaller than this threshold, preventing these tiny connected components from being misclassified as valid targets. By counting the number of pixels in candidate regions after region growing, and only confirming regions as valid object distribution areas if their number exceeds a pixel threshold, not only can noisy regions be effectively eliminated, reducing unnecessary subsequent calculations, but the reliability and interpretability of the segmentation results are also significantly enhanced, thus providing a good foundation for subsequent rendering of target objects.

[0129] In practice, the FloodFill algorithm can be used to process the marker map to obtain at least one object distribution area.

[0130] Figure 4 This is a flowchart illustrating the processing of a FloodFill algorithm provided in an embodiment of this specification.

[0131] like Figure 4 As shown, the core task of determining at least one object distribution region based on the labeled map using the FloodFill algorithm is to divide the binary labeled map into independent connected regions, assign a unique segmentation value (0.1-1.0) to each region, and filter out tiny regions with less than 30 pixels.

[0132] The specific process is as follows: Assume the input marker image is as follows (5×5 matrix, 0 = background, 1 = target object):

[0133]

[0134] Step 1: Initialize the segmentation result image

[0135] Create an m_SegmentResult with the same size as the marker map, and initialize all pixels to 0 (indicating unsegmented).

[0136] Example results:

[0137]

[0138] Step 2: Traverse all pixels.

[0139] Scan row by row from left to right, and check if the current pixel (x, y) satisfies the following two conditions:

[0140] Condition 1: flags[x][y] == 1 (Target object exists)

[0141] Condition 2: m_SegmentResult[x][y] == 0 (unsegmented)

[0142] Example: When scanning (0,0): flags[0][0] = 0, skip; When scanning (1,1): flags[1][1] = 1 and not split, the condition is met;

[0143] Step 3: Generate random partition values.

[0144] Formula: value=RandomFloat()*0.9+0.1.

[0145] Example: Generate 0.3 for the region.

[0146] It's important to note that `RandomFloat()` is a function that generates a random floating-point number within the range [0, 1). In most programming languages ​​(such as C, C++, Java, Python, JavaScript, etc.), `RandomFloat()` or `Math.random()` returns a random value within a half-open interval greater than or equal to 0 and strictly less than 1. Multiplying by the floating-point number 0.9 and adding it to the floating-point number 0.1 results in a segmentation value between (0.1 and 1.0). This allows the object's distribution area to be distinguished from the background.

[0147] Step 4: Perform FloodFill (BFS four-neighborhood).

[0148] The BFS queue operations are shown in Table 1.

[0149] Table 1

[0150]

[0151] Result after filling:

[0152]

[0153] Pixel count: Current region pixel count = 3

[0154] Judgment: 3<30.

[0155] Step 5: Clear the small area.

[0156] Reset the 0.3 in the region to 0 (invalid flag):

[0157]

[0158] Step 6: Continue scanning other areas.

[0159] Scanning to (2,3): flags[2][3] = 1 and not split, generate a new value 0.7.

[0160] FloodFill process: Start from (2,3), fill (2,3), (3,2), (3,3); if the number of pixels is 3 < 30, clear it; when scanning to (3,2), it has already been processed and is skipped.

[0161] Final output results

[0162] All regions are less than 30 pixels, and m_SegmentResult is all 0 (no valid segmented region):

[0163]

[0164] Step 106: Generate two-dimensional point cloud clusters within the distribution area of ​​each object, and determine the height of each point in the two-dimensional point cloud cluster based on the height information to obtain three-dimensional point cloud clusters within the distribution area of ​​each object.

[0165] Based on the known distribution area of ​​the object, a 3D point cloud cluster containing height information is generated to provide basic data for object reconstruction.

[0166] It should be noted that although the description uses the "first region" as an example, this point cloud generation method applies to every object distribution region (connected domain). Each region undergoes the same mesh generation and point cloud generation process independently. Although the description uses "first region" to refer to any region, in practice, the same operation is performed in parallel or serially on all regions.

[0167] In one optional implementation of this embodiment, a two-dimensional point cloud cluster is generated in a grid pattern. Specifically, the two-dimensional point cloud cluster is generated in each object distribution area, including the following steps: for a first region in each object distribution area, the grid spacing corresponding to the first distribution area is obtained, and the first region is divided into a first grid according to the grid spacing, wherein the first region is any region in each object distribution area; in each cell of the first grid, regular two-dimensional points are generated to obtain the two-dimensional point cloud cluster corresponding to the first region.

[0168] In actual implementation, the following steps are used to generate a 3D point cloud cluster in a grid pattern in the object distribution area.

[0169] Step 1: Determine the world coordinate system bounding box and calculate the global bounding box (minimum / maximum X, Y values) of the distribution area of ​​all objects in the world coordinate system. This bounding box covers the spatial extent of the distribution area of ​​all objects to be processed.

[0170] Step 2: Global Mesh Generation. Within the world coordinate system bounding box, obtain the mesh spacing corresponding to the first region (this may be preset or adaptive based on the size of the first region). For example, divide the 2D mesh according to a preset mesh spacing (e.g., 0.5 meters). The mesh lines are evenly distributed along the X and Y axes, forming a regular array of cells.

[0171] Step 3: Generate a point at the center of each cell, or generate multiple points evenly (depending on requirements). Here, we assume that one point (particle) is generated for each cell. These particle points have world coordinates (because the grid is divided in the world coordinate system). Convert the world coordinates to UV coordinates (i.e., image pixel coordinates) to obtain the height value from the height map. Obtain the height value from the height map based on the UV coordinates to obtain the 3D point (x_world, y_world, z = height(uv)).

[0172] Step 4: Check Validity: Since the 3D points are generated within the bounding box, not all 3D points are within the first region (because the connected components may be irregularly shaped). Therefore, it is necessary to check whether the generated 3D points are within the first region. If they are, the 3D point is retained; otherwise, it is discarded. In this way, a 3D point cloud cluster is obtained for the first region.

[0173] It should be noted that the height map is obtained in advance, which gives the height value corresponding to each pixel position (uv coordinates).

[0174] In the above embodiments, point cloud clusters are generated within the object distribution area using a grid pattern. The regular grid inherently possesses spatial uniformity, and by dividing the physical space at equal intervals, it fundamentally avoids point cloud holes or clustering that might result from random sampling. Secondly, the grid spacing parameter directly corresponds to the point cloud density; adjusting the grid spacing parameter allows for global control of the density, which is crucial for scenarios requiring precise control of point cloud particle density. Furthermore, the regularized calculation process eliminates search, randomness, and branching decisions, reducing computational complexity and freeing up hardware computing resources.

[0175] In another optional implementation of this embodiment, a two-dimensional point cloud cluster is generated in a random mode. Specifically, the two-dimensional point cloud cluster is generated in the distribution area of ​​each object, including the following steps: for the second region of each object, random two-dimensional points are generated at random positions in the second region to obtain the two-dimensional point cloud cluster corresponding to the distribution area of ​​the object.

[0176] It should be noted that although the description uses the "second region" as an example, this point cloud generation method applies to every object distribution region (connected region). Each region undergoes the same random point cloud generation process independently. Although the description uses "second region" to refer to any region, in practice, the same operation is performed in parallel or serially on all regions.

[0177] In actual implementation, the following steps are used to generate a 3D point cloud cluster in a random pattern in the object distribution area.

[0178] Step 1: Determine the world coordinate system bounding box and calculate the global bounding box (minimum / maximum X, Y values) of the distribution area of ​​all objects in the world coordinate system. This bounding box covers the spatial extent of the distribution area of ​​all objects to be processed.

[0179] Step 2: Within the bounding box of each object region, randomly generate the X and Z world coordinates according to the set sampling density or number.

[0180] It should be noted that these points were generated using the X and Z components of world coordinates. The Y component (height) is unknown at this point and needs to be obtained from the height map later. These points constitute a preliminary two-dimensional point cloud.

[0181] Step 3: Convert world coordinates XZ to UV coordinates: Convert each two-dimensional world coordinate point (X_world, Z_world) generated in the previous step into the corresponding UV coordinates (U, V).

[0182] Step 4: Sample height values ​​from the heightmap. Use the UV coordinates obtained in Step 2 to sample the heightmap texture. The sampling result is a value representing the height. Use this sampled value as the world coordinate Y value (Y_world).

[0183] Step 5: Construct 3D points and check their validity. After the above steps, each randomly generated (X_world, Z_world) point has a corresponding Y_world height value. This forms a 3D world coordinate point (X_world, Y_world, Z_world). The validity of this 3D point is then checked: it is verified whether the point is within the object distribution area. Only 3D points that pass all validity checks are retained. All 3D points (X_world, Y_world, Z_world) that pass the validity checks are collected, and these points constitute the 3D point cloud cluster corresponding to the currently processed object distribution area.

[0184] In the above embodiments, point cloud clusters are generated in a random mode within the object distribution area. First, a two-dimensional point cloud is generated completely randomly within the bottom surface (XZ plane) of the global bounding box of the object distribution area. This means that the X and Z coordinates of the points are randomly scattered, without any preset grid, pattern, or regular arrangement. Since the distribution of objects in nature (such as snow) is inherently disordered and random, influenced by various accidental factors, forced gridding or uniform distribution would appear artificial and repetitive. This purely random point-scattering method directly simulates the core characteristic of object distribution in nature—the irregularity and unpredictability of spatial location. Subsequent validity checks (such as checking whether points are within the area) further ensure that the random points are not only randomly located but also conform to the physical and logical rules of the scene, making the final distribution result both random and disordered yet reasonable and believable, suitable for scenes that pursue a natural and realistic feel.

[0185] In another optional implementation of this embodiment, a two-dimensional point cloud cluster is generated in a hybrid mode.

[0186] It should be noted that the hybrid mode aims to combine the advantages of GridMode and RandomMode, and the generated point cloud simultaneously possesses the following characteristics: avoiding "holes": ensuring basic coverage of the target area; and introducing randomness: breaking the complete regularity of the grid, enhancing the sense of naturalness and realism.

[0187] In actual implementation, the following steps are used to generate a 3D point cloud cluster in a blended mode in the object distribution area.

[0188] Step 1: Determine the blending mode and set the ratio.

[0189] Users can specify the use of a hybrid mode and determine the proportion of points generated by the grid mode (e.g., 50%) and the proportion of points generated by the random mode (e.g., 50%). Alternatively, users can specify the specific number of points generated by each mode (e.g., 100 point clouds generated by the grid mode and 100 point clouds generated by the random mode); and the generation order (either the grid mode first or the random mode first, for example, generating with the grid mode first and then generating with the random mode).

[0190] Step 2: Generate the grid pattern.

[0191] Within the target object distribution area (e.g., "second region"), a grid is generated according to a pre-set grid spacing, and a two-dimensional point cloud (XZ plane) is generated within the grid.

[0192] Perform the same process as described above for each 2D point cloud: obtain its world coordinates (X_grid, Z_grid); convert to UV coordinates; sample the height Y_grid from the height map; perform a validity check; valid points are collected to form a "mesh subset" point cloud (e.g., 100 valid points).

[0193] It should be noted that the grid points are arranged strictly according to the rules, which ensures the uniform coverage and basic density of the point cloud in the target area, effectively reflects the overall shape and range of the area, and avoids large areas of blank space (i.e., "holes").

[0194] Step 3: Execute random pattern generation.

[0195] Within the same target object distribution area, following the previously described random mode process: obtain the global bounding box of the area, and randomly generate a specified number (e.g., 100 points) of two-dimensional points (X_rand, Z_rand) on the bottom surface of the bounding box; convert to UV coordinates; sample the height Y_rand from the height map; perform a validity check; collect the valid points to form a "random subset" point cloud (e.g., 100 valid points).

[0196] Step 4: Merge point clouds.

[0197] The "mesh subset" point cloud generated in step 2 and the "random subset" point cloud generated in step 3 are merged to finally form a hybrid pattern 3D point cloud of the target area (e.g., with 200 points).

[0198] It should be noted that the generation order in the hybrid mode (grid first or random first) does not affect the content of the final result set.

[0199] In an optional implementation of this embodiment, before obtaining the 3D point cloud clusters within the distribution area of ​​each object, the following steps are also included:

[0200] By adding a random height to the height of each point within a preset range, the target height of each point in the two-dimensional point cloud cluster is obtained.

[0201] In this embodiment, a random height (random thickness offset) needs to be added to the point cloud height before generating the 3D point cloud cluster. This step is applicable to point clouds generated in both mesh and random modes. The specific solution is as follows:

[0202] On top of the base height sampled from the height map, a random value within a preset range is superimposed to break the completely flat surface, increasing the randomness and naturalness of the terrain. This involves the following steps:

[0203] Step 1: For each 2D point cloud (points already generated on the XZ plane using either grid mode or random mode), convert the XZ coordinates of the point cloud to UV coordinates; sample the height map to obtain the base height Y_base; generate a random offset, ranging from [min_offset, max_offset] (e.g., -0.1 meters to 0.2 meters); calculate the final height Y_final = Y_base + offset.

[0204] Step 2: Use Y_final as the final height of the point to form a 3D point.

[0205] It should be noted that the range of random offset can be adjusted according to different region types to achieve the best results.

[0206] The above embodiments add random heights to the base heights obtained based on height map sampling, which makes the object rendering effect more random and closer to the natural visual effect.

[0207] Figure 5 This is a flowchart of a point cloud generation algorithm provided in an embodiment of this specification.

[0208] like Figure 5 As shown, firstly, a point cloud generation mode (grid, random, or blended) is selected for each object distribution area; a two-dimensional point cloud (X, Z coordinates) is generated according to the selected mode; the two-dimensional point cloud is then converted into a three-dimensional point cloud (the Y coordinate is obtained by sampling from the height map). Whether to add a random height offset is determined based on the mode (only added for the random mode, including the random portion in the blended mode); the validity is checked, and valid points are added to the point cloud cluster.

[0209] Specific procedures:

[0210] I. Grid Mode:

[0211] Step 1: Obtain the grid spacing for the region (calculated or preset based on the region size and required density).

[0212] Step 2: Divide the area into grids (cells).

[0213] Step 3: Generate regular points within each cell (usually one point per cell, located at the center or offset according to rules).

[0214] Step 4: Obtain a set of two-dimensional points (X, Z).

[0215] Then proceed to the common process: convert each 2D point (X,Z) into UV coordinates; sample the height map to obtain Y; at this point, since it is not a random mode, do not add random height offset; check validity: add valid points to the point cloud cluster.

[0216] II. Random Mode:

[0217] Step 1: Obtain the global bounding box of the region.

[0218] Step 2: Randomly generate a specified number of two-dimensional points (X, Z) within the bounding box.

[0219] Step 3: Convert each 2D point (X,Z) to UV coordinates; sample the height map to obtain Y; because it is a random mode, add a random height offset (within a preset range, such as within 0.5 cm); check the validity, and add valid points to the point cloud cluster.

[0220] III. Hybrid Mode:

[0221] Step 1: In this area, call the grid mode to generate a set of two-dimensional points (X_grid, Z_grid), convert them into three-dimensional points (without adding random height offset) and check their validity to obtain a grid subset point cloud.

[0222] Step 2: In the same area, call the random mode to generate a set of two-dimensional points (X_rand, Z_rand), convert them into three-dimensional points (add random height offset) and check the validity to obtain a random subset point cloud.

[0223] Step 3: Merge the grid subset and the random subset to obtain the final point cloud cluster.

[0224] Step 108: Based on the 3D point cloud clusters within each object distribution area, generate the target mesh for each object distribution area, and render the target object in the image to be rendered based on the target mesh for each object distribution area.

[0225] In one optional implementation of this embodiment, a target mesh for each object distribution region is generated based on the three-dimensional point cloud clusters within each object distribution region. Specifically, this includes the following steps: determining whether the first point cloud cluster and the second point cloud cluster are connected, for a first point cloud cluster within a first object region and a second point cloud cluster within a second object region, wherein the first object region and the second object region are any two object distribution regions within each object distribution region; if the first point cloud cluster and the second point cloud cluster are connected, merging the first point cloud cluster and the second point cloud cluster to obtain a merged point cloud cluster; and generating the target mesh for the first object region and the second object region based on the merged point cloud cluster.

[0226] It's important to note that object distribution regions are divided by pixels. It's possible that two object distribution regions are separated by only a few pixels—for example, just one pixel—but will actually be classified as two separate regions. During the generation of particle point clouds, if the particle point clouds are large, the particle point clouds of two regions might be adjacent, or even a single particle point cloud might span two object distribution regions. In such cases, to avoid noticeable breaks between objects in adjacent regions in the final visual result, connected point cloud clusters should be merged. This ensures that the target object appears continuous in the final rendering, without obvious breaks, thus improving the visual quality of object rendering.

[0227] Among them, determining whether the first point cloud cluster and the second point cloud cluster are connected can be achieved through common connectivity determination methods, including but not limited to the following:

[0228] (1) Spatial distance analysis: Calculate the nearest point distance between two point cloud clusters. If the minimum distance is less than a preset threshold (which is usually set based on point cloud density and application scenario), they are considered to be "connected".

[0229] (2) Voxel / spatial occupancy analysis: Voxelize the point cloud. If the points of two point cloud clusters fall within the same voxel, or if the voxels they occupy are adjacent (shared faces, edges, corners), then they are considered to be spatially connected.

[0230] This optimization scheme effectively solves the problem of gaps at the contact surfaces caused by generating independent meshes for physically adjacent or contacting objects. It addresses the issue of an object being divided into adjacent regions due to point cloud segmentation errors (oversegmentation) by dynamically checking the spatial connectivity of every two point cloud clusters before generating the mesh, merging connected clusters, and then generating a unified mesh based on the merged clusters. This significantly improves the physical realism and geometric coherence of the generated mesh.

[0231] In one optional implementation of this embodiment, determining whether the first point cloud cluster and the second point cloud cluster are connected includes the following steps: for any first point in the first point cloud cluster, if there is a second point in the second point cloud cluster whose distance from the first point satisfies a preset adjacent condition, then the first point cloud cluster and the second point cloud cluster are determined to be connected.

[0232] It should be noted that this scheme provides a connectivity determination method based on point-to-point distance to determine whether two point cloud clusters (point clouds in different blocks) belong to the same physical object or need to be merged and reconstructed. Its core logic is: if any pair of point clouds in the two clusters satisfies a preset condition, then the two clusters are determined to be connected.

[0233] This embodiment utilizes the simple yet powerful mechanism of "finding cross-cluster neighboring point pairs" to effectively identify point cloud clusters that should belong to the same object or be in close contact in space. When such connections are detected, subsequent point cloud merging and unified mesh generation steps ensure that the final generated mesh is continuous and complete, completely avoiding the problem of object mesh breakage caused by spatial block processing, and significantly improving the geometric consistency and visual / physical rationality of the 3D reconstruction results.

[0234] Figure 6 This is a flowchart of a cluster connectivity optimization algorithm provided in an embodiment of this specification.

[0235] like Figure 6As shown, taking the snow in the scene to be rendered as the target object as an example, the specific steps of cluster connectivity optimization include the following:

[0236] Step 1: Input the point cloud cluster set.

[0237] In the above embodiments, the number of 3D point cloud clusters obtained is the same as the number of 3D point cloud clusters input. Each pair of 3D point cloud clusters forms a cluster pair, and each 3D point cloud cluster represents a potential snow cover area.

[0238] Step 2: Determine the number of clusters.

[0239] Specifically, determine if the number of clusters is ≤1; if the number of clusters is ≤1: directly return the original set; because single / zero clusters do not require connection optimization; if the number of clusters is >1: continue the subsequent optimization process.

[0240] Step 3: Build a NeighborSearch for each cluster.

[0241] For example, constructing a spatial hash table: dividing 3D space into regular grids; quickly locating the grid where the point cloud is located using a hash function.

[0242] For example, constructing a KD-tree: a binary tree structure recursively partitions the space to optimize the efficiency of nearest neighbor search.

[0243] It should be noted that the purpose of step 3 is to accelerate the cluster connection optimization process, so any nearest neighbor algorithm that can accelerate neighborhood search can be used.

[0244] Step 4: Traverse all cluster pair combinations to determine if there are any undetected cluster pairs.

[0245] Specifically, calculate all possible cluster combinations.

[0246] Processing order: For example, sort by spatial proximity and prioritize cluster pairs with high probability of boundary overlap.

[0247] Step 5: If there are still cluster pairs to be detected, check whether there are intersecting particle point clouds between the clusters.

[0248] For example, with a hash table scheme, the nearest possible point to point cloud p is either in the cell containing p or within 26 cells surrounding p, thus avoiding a global scan of all points. This significantly improves the efficiency of neighborhood search.

[0249] Intersection determination: For example, the distance between two particle point clouds is ≤ the snow particle diameter × 2.

[0250] Step 6: Merge point cloud clusters.

[0251] Then continue to the next pair. Finally, the updated segmentation result map is obtained (updated point cloud clusters and corresponding updated object distribution regions). The terrain / object type can also be reclassified for each updated object distribution region based on the updated point cloud clusters or updated object distribution regions. For example, the number of points in an updated point cloud cluster can be used to determine whether the cluster belongs to a terrain type (e.g., snowfield, snow accumulation on a hillside, snow accumulation on a roof) or an object type (e.g., snow accumulation on a car roof). Specifically, if the number of points in a point cloud cluster is below a set threshold, it is classified as an object type; otherwise, it is classified as a terrain type. As another example, the number of pixels in each region within an updated object distribution region can be used to determine whether the object in that region belongs to a terrain type / object type. Specifically, if the number of pixels in a region is below a preset threshold, it is classified as an object type; otherwise, it is classified as a terrain type.

[0252] Step 7: Output the optimized cluster set.

[0253] The final output includes: a merged and optimized set of clusters; terrain / object classification labels; and an updated spatial index.

[0254] In one optional implementation of this embodiment, a target mesh for each object distribution area is generated based on the three-dimensional point cloud clusters within each object distribution area. Specifically, the steps include: generating an initial mesh for the three-dimensional point cloud clusters in the third region of each object distribution area; if the number of cells in the initial mesh is greater than a number threshold, splitting the initial mesh until the number of cells in each sub-mesh obtained after splitting is less than or equal to the number threshold, thereby obtaining the target mesh for the third region, wherein the third region is any region in each object distribution area.

[0255] Specifically, mesh splitting includes the following steps: Initial mesh generation: Generate a mesh using the Marching Cubes algorithm or based on a heightmap; Split trigger threshold determination: Splitting is initiated when the number of cells (i.e., the number of triangles) in the initial mesh exceeds a configured threshold (e.g., 10,000 triangles). Specifically, spatial partitioning: Recursively partition the AABB bounding box of the initial mesh using a quadtree (for 2D terrain) or an octree (for 3D objects) to construct a spatial hierarchy; Triangle allocation: Calculate the geometric center of each triangle (the average of its three vertices), and assign the triangles to the corresponding child nodes (i.e., spatial sub-regions) in the quadtree / octree based on the center coordinates; Output sub-mesh set: Each sub-mesh is an independent mesh object containing its own vertices, indices, normals, UVs, etc. The number of triangles in each sub-mesh is less than or equal to the splitting threshold.

[0256] In the above embodiments, grid splitting is triggered by threshold judgment. By combining quadtree / octree spatial partitioning with precise allocation of triangles based on the geometric center, large grids are split into smaller grids that are more suitable for rendering, improving the rendering effect of objects.

[0257] Figure 7 This is a flowchart of a grid splitting algorithm provided by an embodiment of this specification.

[0258] Step 1: Input grid data (vertex array + triangle index array).

[0259] Step 2: Determine whether splitting is required

[0260] Flowchart: Determine whether the number of triangles is < or = the expected value, where expectedTriangleCount is the configured ideal triangle number threshold.

[0261] If the total number of triangles ≤ the threshold, do not split and directly return the grid.

[0262] Otherwise, enter the splitting process.

[0263] Step 3: Calculate the overall geometric properties.

[0264] (1) Calculate the overall AABB bounding box.

[0265] Calculate the overall AABB bounding box of the grid. Specifically, traverse all vertices and determine the boundaries of the bounding box based on the min and max of the coordinates.

[0266] (2) Calculate the geometric center points of all triangles.

[0267] Calculate the center points of all triangles. In subsequent quadtree partitioning, it is based on this center point to determine which sub-region it falls into.

[0268] Step 4: Initialize the queue for recursive splitting.

[0269] Put the current grid task (the entire grid) into the pending queue and process it recursively by the BFS queue.

[0270] (1) Judge the depth. The current depth < maxDepth to prevent infinite splitting and avoid stack overflow in extreme cases. If it exceeds the maximum depth, no further splitting is performed.

[0271] (2) Judge whether the number of triangles is too large: Judge whether the number of triangles is >= expectedTriangleCount. If it still exceeds the threshold, perform quadtree partitioning.

[0272] (3) Create 4 child nodes. Draw a line in the middle of the XZ plane to generate four sub AABBs; add the triangles to the corresponding child node queues according to the position of the triangle center point. Specifically, determine which quadrant the triangle center (cx, cy, cz) falls into and add it to the corresponding child node queue.

[0273] Step 5: Update the queue & repeat recursion.

[0274] Each child node becomes a new "mesh splitting task" and is put into the queue. Continue to repeat the quadtree division until all sub-meshes meet the condition: the number of triangles <= expectedTriangleCount.

[0275] Step 6: Post-processing of small meshes (to avoid fragmentation). If the number of triangles < expectedTriangleCount * 0.1f, if the number of triangles in a certain sub-mesh is too small, it is considered too fragmented and needs to be merged.

[0276] Step 7: Find the nearest adjacent sub-meshes (such as comparing the distances of the AABB center points); merge the triangle data of the small meshes into the nearest neighbor sub-meshes and clean up the merged small meshes.

[0277] In the above embodiments, through the quadtree space division technology in the X-Z plane, the adaptive automatic splitting of large snow accumulation meshes is realized, effectively avoiding excessive fragmentation and improving the rendering clipping and local loading efficiency. At the same time, by combining the assigned flag with the BFS traversal and spatial inclusion judgment, it is ensured that each triangle is only assigned once, maintaining the integrity of the index and topological consistency, and avoiding the problems of duplicate indexing and cracks that may occur in traditional methods, thus significantly optimizing the rendering performance of large-scale meshes.

[0278] Figure 8 It is a flowchart of a mesh generation algorithm provided by the embodiments of this specification.

[0279] As Figure 8 shown, generating a mesh based on a three-dimensional point cloud cluster specifically includes the following steps:

[0280] Step 1: Input a three-dimensional point cloud cluster.

[0281] Step 2: Traverse each cluster, independently process each cluster, and generate the corresponding snow accumulation mesh.

[0282] Step 3: Cluster Type Determination. Generate either a terrain snow mesh or an object snow mesh. If the snow type represented by the 3D point cloud cluster is a terrain type, you can choose to generate the mesh using the marching cubes method or based on a heightmap. In this process, the mesh corresponding to the point cloud cluster of the terrain type is generated based on the heightmap. Specifically, a mesh is generated within the object distribution area, with each grid point serving as a vertex. Height information is obtained from the heightmap to construct the terrain snow mesh.

[0283] If the object type represented by the 3D point cloud cluster is an object type, the marching cubes method generates an object volume snow mesh.

[0284] Specifically, for each object distribution region, the 3D point cloud cluster of the object distribution region is converted into a mesh, including the following steps: For each object distribution region, the corresponding 3D point cloud cluster is voxelized, that is, the 3D space where the point cloud cluster is located is discretized into regular small cubic meshes (voxels); the signed distance field is calculated: the signed distance value is calculated for the vertices of each voxel mesh; the Marching Cubes algorithm is applied: each voxel cell is traversed, and the topological structure of the isosurface within the cell is determined based on the SDF values ​​of its 8 vertices, and the corresponding triangular facets are generated; the triangular facets generated by all voxel cells are collected to form the final triangular mesh, representing the surface of the target object within the object distribution region.

[0285] The mesh post-processing workflow includes multiple steps, in the following order:

[0286] (1) Mesh simplification: The number of triangles is reduced using an edge-folding algorithm. It should be understood that because the number of faces in the generated mesh is very high (depending on the number of voxels), simplification can reduce the number of faces and improve performance.

[0287] (2) Mesh smoothing: Use Laplacian smoothing to reduce surface noise. Mesh smoothing can reduce the indentation between particle point clouds and improve the visual effect.

[0288] (3) Hole filling: Since smoothing operations may cause holes (vertices to separate), this step identifies holes and triangulates them to ensure that the mesh is closed.

[0289] (4) Mesh Cleanup: Clean up the mesh topology by removing duplicate vertices, overlapping triangles, coplanar triangles, etc. This step may use vertex hashing to merge vertices that are very close together.

[0290] (5) Face cleanup: Delete unnecessary triangles to reduce the number of faces. Especially for snow accumulation objects, the lower half of the faces (with normals facing down) are not visible in the game, so deleting these faces can significantly reduce the number of faces.

[0291] (6) Normal calculation: Calculate the normal of each vertex for lighting calculation.

[0292] (7) UV generation: Generate texture coordinates for the mesh so that texture maps (such as snow textures) can be sampled.

[0293] (8) SplitMesh If the generated mesh is too large, it may need to be split into smaller blocks for easier rendering and management.

[0294] (9) Output final mesh: Output the processed mesh data for game rendering.

[0295] In some embodiments, the object rendering method described above also uses a GPU-accelerated processing procedure.

[0296] Figure 9 This is an architecture diagram of a GPU-accelerated implementation provided in the embodiments of this specification.

[0297] like Figure 9 As shown, the CPU main control flow includes the start and end of the overall control process. Platform device detection involves detecting available OpenCL platforms and devices (such as GPUs). Context and queue creation involves creating OpenCL contexts and command queues for managing execution on the GPU.

[0298] SDF distance field calculation (executed on GPU). Point cloud data buffer: Transfers point cloud data to the GPU (Graphics Processing Unit) buffer. KD-tree node buffer: Constructs a KD-tree (for spatial acceleration structure) and buffers node data to the GPU to accelerate SDF computation. SDF kernel execution: Uses the KD-tree for accelerated lookups during SDF computation.

[0299] CPU-accelerated Marching Cubes mesh reconstruction (the Marching Cubes algorithm is executed on the GPU). Data preparation and buffering: SDF data buffer: Allocates a GPU buffer for SDF (Signed Distance Field) data. Marching Cubes kernel: The Marching Cubes kernel program runs on the GPU, processing voxels in parallel and generating triangles.

[0300] Vertex Index Output: Outputs the vertex and index data generated on the GPU to the buffer.

[0301] Final mesh output: Vertex and index data are read from the GPU back to the CPU to form the final mesh data.

[0302] OpenCL resource release: Release OpenCL resources (such as buffers, contexts, etc.).

[0303] In some embodiments, the object rendering method of this specification also provides rich parameter configuration options for controlling various aspects of the processing. Specific parameter configurations include the following aspects:

[0304] (1) Mesh generation parameters:

[0305] Mesh simplification ratio: Controls the number of triangles in the output mesh.

[0306] Mesh smoothing iteration count: controls the degree of surface smoothing.

[0307] Normal calculation switch: controls whether to calculate vertex normal vectors, used for lighting calculations.

[0308] UV coordinate generation switch: Controls whether to generate texture coordinates for material mapping.

[0309] UV scaling and offset parameters: control the scaling and offset of texture coordinates.

[0310] (2) Mesh parameters:

[0311] Particle radius: controls the range of influence of a single particle.

[0312] Grid cell size: controls the precision of spatial partitioning.

[0313] Minimum cluster size: filters out point cloud clusters that are too small.

[0314] (3) Switch control parameters:

[0315] Object thickness: Controls the vertical thickness of the object.

[0316] Particle generation mode: Select grid mode (0), random mode (1) or mixed mode (2).

[0317] Random particle count: The total number of particles when using random mode.

[0318] World coordinate range: Defines the minimum and maximum coordinate boundaries of the processing area.

[0319] (4) Mesh splitting parameters:

[0320] Desired number of vertices: Controls the maximum number of vertices in a single mesh segment.

[0321] Desired number of triangles: Controls the maximum number of triangles in a single mesh segment, which is controlled by a parameter in the mesh splitting function.

[0322] Maximum depth of a quadtree: limits the maximum number of levels that can be recursively subdivided in space.

[0323] Small grid merging threshold: Grids with fewer than 10% of the expected number of triangles will be merged.

[0324] Splitting criteria: Splitting is triggered when the number of grid triangles is greater than or equal to the expected value.

[0325] The following is in conjunction with the appendix Figure 10 Taking the generation of snow in a game scene using the object rendering method provided in this specification as an example, the object rendering method will be further explained. Figure 10 The flowchart of an object rendering method according to an embodiment of this specification is shown, which specifically includes the following steps.

[0326] Configure the relevant parameters.

[0327] (1) Mesh generation parameters:

[0328] Mesh simplification ratio: Controls the number of triangles in the output mesh. A typical value is 0.2, which means that 20% of the original mesh faces are retained.

[0329] Mesh smoothing iteration count: controls the degree of surface smoothing, with a typical value of 10 iterations.

[0330] Normal calculation switch: controls whether to calculate vertex normal vectors, used for lighting calculations.

[0331] UV coordinate generation switch: Controls whether to generate texture coordinates for material mapping.

[0332] UV scaling and offset parameters: Control the scaling and offset of texture coordinates. The default scaling is 10.0 times.

[0333] (2) Mesh parameters:

[0334] Particle radius: controls the range of influence of a single particle, with a typical value of 1.0 unit.

[0335] Grid cell size: controls the precision of spatial division, with a typical value of 0.5 units.

[0336] Minimum cluster size: filters out point cloud clusters that are too small; a typical value is 40 points.

[0337] (3) Switch control parameters:

[0338] Snow thickness: controls the vertical thickness of the snow layer, typically 0.5 units.

[0339] Particle generation mode: Select grid mode (0), random mode (1) or mixed mode (2).

[0340] Random particle count: The total number of particles when using random mode, typically 4 million.

[0341] World coordinate range: Defines the minimum and maximum coordinate boundaries of the processing area.

[0342] (4) Mesh splitting parameters:

[0343] Expected number of vertices: Controls the maximum number of vertices in a single mesh segment, typically 10,000 vertices.

[0344] Expected number of triangles: Controls the maximum number of triangles in a single mesh segment. It is controlled by a parameter in the mesh splitting function, with a typical value of 40,000 triangles.

[0345] Maximum depth of a quadtree: limits the maximum number of levels that can be recursively subdivided in space.

[0346] Small grid merging threshold: Grids with fewer than 10% of the expected number of triangles will be merged.

[0347] Splitting criteria: Splitting is triggered when the number of grid triangles is greater than or equal to the expected value.

[0348] S1: Data preprocessing. Check the resolution consistency between the height map and the marker map.

[0349] S2: Region Segmentation. Task: Segment the marked map into at least one object distribution region. Refer to the above embodiment for the specific implementation process.

[0350] S3: Point Cloud Generation. A three-dimensional particle point cloud is generated within the object's distribution area to obtain a three-dimensional point cloud cluster. Refer to the above embodiment for the specific implementation process.

[0351] S4: Cluster connectivity optimization. Optimize the connectivity and distribution of point cloud clusters. For specific implementation details, refer to the above embodiments.

[0352] S5: Mesh Reconstruction. The point cloud data is converted into a 3D mesh. Refer to the above embodiment for the specific implementation process.

[0353] S6: Mesh post-processing. Laplacian smoothing reduces surface noise; edge folding algorithm simplifies the mesh; vertex normals and UV coordinates are calculated; face cleaning and isolated point removal are performed. Refer to the above embodiments for the specific implementation process.

[0354] Mesh splitting. Large meshes are split into smaller, rendering-appropriate meshes. Specifically, splitting is initiated when the number of mesh triangles is greater than or equal to the configured expected value. Key operations include: calculating the overall AABB bounding box of the mesh; calculating the coordinates of the geometric center point of each triangle; constructing a hierarchical structure using a quadtree spatial partitioning algorithm; allocating space based on the triangle center point positions; optimizing the merging of smaller meshes to avoid excessive fragmentation; and maintaining the integrity and continuity of the triangle indices. Refer to the above embodiment for the specific implementation process. Output: Multiple optimized arrays of triangle indices.

[0355] GPU-accelerated processes include: GPU-accelerated SDF calculations and Marching Cubes algorithms, mesh post-processing, and point cloud generation.

[0356] Corresponding to the above method embodiments, this specification also provides embodiments of object rendering apparatus. Figure 11 A schematic diagram of an object rendering apparatus according to one embodiment of this specification is shown. Figure 11 As shown, the device includes:

[0357] The acquisition module 302 is configured to acquire the image to be rendered, the height information of the image to be rendered, and object distribution markers;

[0358] The determination module 304 is configured to determine at least one object distribution region of the target object in the rendering screen based on object distribution markers;

[0359] The first generation module 306 is configured to generate two-dimensional point cloud clusters in each object distribution area, and determine the height of each point in the two-dimensional point cloud cluster based on the height information, so as to obtain three-dimensional point cloud clusters in each object distribution area.

[0360] The second generation module 308 is configured to generate target meshes for each object distribution area based on the 3D point cloud clusters within each object distribution area, and to render the target objects in the rendering screen based on the target meshes for each object distribution area.

[0361] Optionally, the object distribution marker is a marker map of the target object. The determination module is further configured to: determine the first pixel point in the marker map whose first pixel value is the target value; determine the corresponding first object distribution area starting from the first pixel point, wherein the target value is used to indicate that a target object exists at the corresponding pixel point in the marker map; update the pixel value of each pixel point in the first object distribution area in the marker map; return to the steps of determining the first pixel point in the marker map whose first pixel value is the target value and determining the corresponding first object distribution area starting from the first pixel point, until there are no pixels in the marker map with a pixel value of the target value, thereby obtaining the object distribution areas in the image to be rendered.

[0362] Optionally, the determining module 304 is further configured to: retrieve a second pixel from the target queue corresponding to the first pixel, wherein the target queue corresponding to the first pixel is used to store the pixels found starting from the first pixel, and the second pixel is the pixel to be processed in the target queue; determine at least one third pixel with a pixel value of the target value among the neighbors of the second pixel, add the third pixel to the queue, and return to execute the step of retrieving the second pixel from the target queue corresponding to the first pixel until the target queue is empty, thereby obtaining the first object distribution area corresponding to the first pixel.

[0363] Optionally, the determining module 304 is further configured to: obtain the candidate object distribution area corresponding to the first pixel point until the target queue is empty; determine the number of pixels in the candidate object distribution area; and determine the candidate object distribution area as the first object distribution area corresponding to the first pixel point if the number of pixels is greater than the pixel threshold.

[0364] Optionally, the first generation module 306 is further configured to: for a first region in each object distribution region, obtain the grid spacing corresponding to the first distribution region, and divide the first region into a first grid according to the grid spacing, wherein the first region is any region in each object distribution region; generate regular two-dimensional points in each cell of the first grid to obtain a two-dimensional point cloud cluster corresponding to the first region.

[0365] Optionally, the first generation module 306 is further configured to: generate random two-dimensional points at random locations within the second region of each object's region, thereby obtaining a two-dimensional point cloud cluster corresponding to the object's distribution area.

[0366] Optionally, before obtaining the three-dimensional point cloud clusters within the distribution area of ​​each object, the first generation module is further configured to: add a random height to the height of each point within a preset range to obtain the target height of each point in the two-dimensional point cloud cluster.

[0367] Optionally, the second generation module 308 is further configured to: determine whether the first point cloud cluster and the second point cloud cluster are connected for the first point cloud cluster in the first object region and the second point cloud cluster in the second object region, wherein the first object region and the second object region are any two object distribution regions in each object distribution region; if the first point cloud cluster and the second point cloud cluster are connected, merge the first point cloud cluster and the second point cloud cluster to obtain a merged point cloud cluster; and generate the target mesh of the first object region and the second object region based on the merged point cloud cluster.

[0368] Optionally, the second generation module 308 is further configured to: for a first point in the first point cloud cluster, if there is a second point in the second point cloud cluster whose distance to the first point satisfies a preset adjacent condition, then determine that the first point cloud cluster and the second point cloud cluster are connected, wherein the first point is any point in the first point cloud cluster and the second point is any point in the second point cloud cluster.

[0369] Optionally, the second generation module 308 is further configured to: generate an initial mesh for the three-dimensional point cloud clusters in the third region of each object distribution region; if the number of cells in the initial mesh is greater than the number threshold, split the initial mesh until the number of cells in each sub-mesh obtained after splitting is less than or equal to the number threshold, and obtain the target mesh of the third region, wherein the third region is any region in each object distribution region.

[0370] The above is a schematic scheme of an object rendering apparatus according to this embodiment. It should be noted that the technical solution of this object rendering apparatus and the technical solution of the object rendering method described above belong to the same concept. For details not described in detail in the technical solution of the object rendering apparatus, please refer to the description of the technical solution of the object rendering method described above.

[0371] Figure 12 A structural block diagram of a computing device 400 according to one embodiment of this specification is shown. The components of the computing device 400 include, but are not limited to, a memory 410 and a processor 420. The processor 420 is connected to the memory 410 via a bus 430, and a database 450 is used to store data.

[0372] The computing device 400 also includes an access device 440, which enables the computing device 400 to communicate via one or more networks 460. Examples of these networks include Public Switched Telephone Network (PSTN), Local Area Network (LAN), Wide Area Network (WAN), Personal Area Network (PAN), or combinations of communication networks such as the Internet. The access device 440 may include one or more of any type of wired or wireless network interface (e.g., a network interface controller (NIC)), such as an IEEE 802.11 Wireless Local Area Network (WLAN) wireless interface, a Wi-MAX (Worldwide Interoperability for Microwave Access) interface, an Ethernet interface, a Universal Serial Bus (USB) interface, a cellular network interface, a Bluetooth interface, or a Near Field Communication (NFC) interface.

[0373] In one embodiment of this specification, the aforementioned components of the computing device 400 and Figure 12 Other components, not shown, can also be connected to each other, for example, via a bus. It should be understood that... Figure 12 The block diagram of the computing device shown is for illustrative purposes only and is not intended to limit the scope of this specification. Those skilled in the art can add or replace other components as needed.

[0374] Computing device 400 can be any type of stationary or mobile computing device, including mobile computers or mobile computing devices (e.g., tablet computers, personal digital assistants, laptop computers, notebook computers, netbooks, etc.), mobile phones (e.g., smartphones), wearable computing devices (e.g., smartwatches, smart glasses, etc.) or other types of mobile devices, or stationary computing devices such as desktop computers or personal computers (PCs). Computing device 400 can also be a mobile or stationary server.

[0375] The processor 420 is configured to execute the following computer-executable instructions, which, when executed by the processor, implement the steps of the object rendering method described above.

[0376] The above is an illustrative scheme of a computing device according to this embodiment. It should be noted that the technical solution of this computing device and the technical solution of the object rendering method described above belong to the same concept. For details not described in detail in the technical solution of the computing device, please refer to the description of the technical solution of the object rendering method described above.

[0377] An embodiment of this specification also provides a computer-readable storage medium storing computer-executable instructions that, when executed by a processor, implement the steps of the object rendering method described above.

[0378] The above is an illustrative scheme of a computer-readable storage medium according to this embodiment. It should be noted that the technical solution of this storage medium and the technical solution of the object rendering method described above belong to the same concept. For details not described in detail in the technical solution of the storage medium, please refer to the description of the technical solution of the object rendering method described above.

[0379] An embodiment of this specification also provides a computer program, wherein when the computer program is executed in a computer, it causes the computer to perform the steps of the above-described object rendering method.

[0380] The above is an illustrative scheme of a computer program according to this embodiment. It should be noted that the technical solution of this computer program and the technical solution of the object rendering method described above belong to the same concept. For details not described in detail in the technical solution of the computer program, please refer to the description of the technical solution of the object rendering method described above.

[0381] The foregoing has described specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than that shown in the embodiments and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are possible or may be advantageous.

[0382] The computer instructions include computer program code, which may be in the form of source code, object code, executable file, or certain intermediate forms. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording media, USB flash drive, portable hard drive, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium may be appropriately added or removed according to the requirements of patent practice. For example, in some regions, according to patent practice, computer-readable media may not include electrical carrier signals and telecommunication signals.

[0383] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that the embodiments in this specification are not limited to the described order of actions, because according to the embodiments in this specification, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in this specification are all preferred embodiments, and the actions and modules involved are not necessarily essential to the embodiments in this specification.

[0384] In the above embodiments, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0385] The preferred embodiments disclosed above are merely illustrative of this specification. The optional embodiments do not exhaustively describe all details, nor do they limit the invention to the specific implementations described. Clearly, many modifications and variations can be made based on the embodiments described herein. These embodiments are selected and specifically described in this specification to better explain the principles and practical applications of the embodiments, thereby enabling those skilled in the art to better understand and utilize this specification. This specification is limited only by the claims and their full scope and equivalents.

Claims

1. An object rendering method, characterized in that, include: Obtain the image to be rendered, the height information of the image to be rendered, and the object distribution markers; Based on the object distribution markers, at least one object distribution region of the target object in the image to be rendered is determined; Two-dimensional point cloud clusters are generated within each object distribution area, and the height of each point in the two-dimensional point cloud clusters is determined based on the height information to obtain three-dimensional point cloud clusters within each object distribution area. Based on the 3D point cloud clusters within the distribution areas of each object, a target mesh is generated for each object distribution area, and the target object is rendered in the image to be rendered based on the target mesh of each object distribution area.

2. The method according to claim 1, characterized in that, The object distribution marker is a marker map of the target object, and the step of determining at least one object distribution region of the target object in the rendering screen based on the object distribution marker includes: A first pixel with a target value is determined in the marker image, and a corresponding first object distribution area is determined with the first pixel as the starting point. The target value is used to indicate that the target object exists at the corresponding pixel in the marker image. Update the pixel values ​​of each pixel within the distribution area of ​​the first object in the marker image; Return to the step of determining the first pixel point with the first pixel value of the target value in the marker image, and determining the corresponding first object distribution area with the first pixel point as the starting point, until there are no pixels with the pixel value of the target value in the marker image, and obtain the distribution areas of each object in the image to be rendered.

3. The method according to claim 2, characterized in that, The step of determining the corresponding first object distribution region starting from the first pixel includes: Take the second pixel from the target queue corresponding to the first pixel, wherein the target queue corresponding to the first pixel is used to store the pixel found starting from the first pixel, and the second pixel is the pixel currently to be processed in the target queue; Determine at least one third pixel whose pixel value is the target value among the neighboring pixels of the second pixel, add the third pixel to the queue, and return to execute the step of retrieving the second pixel from the target queue corresponding to the first pixel until the target queue is empty, thereby obtaining the first object distribution area corresponding to the first pixel.

4. The method according to claim 3, characterized in that, The method further includes obtaining the first object distribution region corresponding to the first pixel point until the target queue is empty. Until the target queue is empty, the candidate object distribution area corresponding to the first pixel is obtained; Determine the number of pixels in the distribution area of ​​the candidate objects; If the number of pixels is greater than the pixel threshold, the candidate object distribution area is determined to be the first object distribution area corresponding to the first pixel.

5. The method according to claim 1, characterized in that, The generation of two-dimensional point cloud clusters within the distribution areas of each object includes: For a first region in each object distribution region, the grid spacing corresponding to the first distribution region is obtained, and the first region is divided into a first grid according to the grid spacing, wherein the first region is any one of the object distribution regions; In each cell of the first grid, regular two-dimensional points are generated to obtain the two-dimensional point cloud cluster corresponding to the first region.

6. The method according to claim 1, characterized in that, The generation of two-dimensional point cloud clusters within the distribution areas of each object includes: For each object's second region, random two-dimensional points are generated at random locations within the second region to obtain a two-dimensional point cloud cluster corresponding to the object's distribution area.

7. The method according to claim 1, characterized in that, Before obtaining the three-dimensional point cloud clusters within the distribution areas of each object, the process further includes: By adding a random height to the height of each point within a preset range, the target height of each point in the two-dimensional point cloud cluster is obtained.

8. The method according to claim 1, characterized in that, The step of generating target meshes for each object distribution region based on 3D point cloud clusters within each object distribution region includes: For a first point cloud cluster within a first object region and a second point cloud cluster within a second object region, determine whether the first point cloud cluster and the second point cloud cluster are connected, wherein the first object region and the second object region are any two object distribution regions within each object distribution region; When the first point cloud cluster and the second point cloud cluster are connected, the first point cloud cluster and the second point cloud cluster are merged to obtain a merged point cloud cluster. Based on the merged point cloud cluster, target meshes for the first object region and the second object region are generated.

9. The method according to claim 8, characterized in that, Determining whether the first point cloud cluster and the second point cloud cluster are connected includes: For a first point in the first point cloud cluster, if there is a second point in the second point cloud cluster whose distance from the first point meets a preset adjacent condition, then the first point cloud cluster and the second point cloud cluster are determined to be connected, wherein the first point is any point in the first point cloud cluster and the second point is any point in the second point cloud cluster.

10. The method according to claim 1, characterized in that, The step of generating target meshes for each object distribution region based on 3D point cloud clusters within each object distribution region includes: For the three-dimensional point cloud clusters in the third region of each object distribution area, an initial mesh for the third region is generated; If the number of cells in the initial grid is greater than the number threshold, the initial grid is split until the number of cells in each sub-grid obtained after splitting is less than or equal to the number threshold, thereby obtaining the target grid of the third region, wherein the third region is any region among the distribution regions of each object.

11. An object rendering apparatus, characterized in that, include: The acquisition module is configured to acquire the image to be rendered, the height information of the image to be rendered, and object distribution markers; The determination module is configured to determine at least one object distribution region of the target object in the image to be rendered based on the object distribution marker; The first generation module is configured to generate two-dimensional point cloud clusters in each object distribution area, and determine the height of each point in the two-dimensional point cloud cluster based on the height information, thereby obtaining three-dimensional point cloud clusters in each object distribution area. The second generation module is configured to generate target meshes for each object distribution area based on the three-dimensional point cloud clusters within each object distribution area, and to render the target objects in the image to be rendered based on the target meshes for each object distribution area.

12. A computing device, characterized in that, include: Memory and processor; The memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions, which, when executed by the processor, implement the steps of the object rendering method according to any one of claims 1-10.

13. A computer-readable storage medium, characterized in that, It stores computer-executable instructions that, when executed by a processor, implement the steps of the object rendering method according to any one of claims 1-10.

14. A computer program product, characterized in that, Includes a computer program / instructions that, when executed by a processor, implement the steps of the object rendering method according to any one of claims 1-10.

Images