A bulletin board interaction pickup method and system based on block coding

Abstract

The application relates to the technical field of graphics processing, and particularly discloses a bulletin board interaction pickup method and system based on grouping coding. In view of the problem that a traditional bulletin board pickup scheme needs to repeatedly render or additionally use 32-bit textures, resulting in large GPU performance loss and poor real-time performance in a massive bulletin board scene, the application first continuously divides bulletin boards B1 to Bn into at most 256 groups, and batch renders the bulletin boards to a texture T0, wherein the R, G and B channels store colors, and the A channel stores group IDs; then the dynamic bulletin board is redrawn, the A channel of a T0 point selected pixel is sampled to obtain a group ID, the absolute bulletin board ID is calculated by combining the relative number, the position information is called according to the absolute ID, the position information is rendered to 1x1 pixels and is subjected to a depth test to retain the nearest ID, and finally, the CPU reads and decodes the ID to complete the pickup. The method does not need additional textures or repeated rendering, greatly reduces the GPU load, improves the pickup accuracy and real-time performance, and adapts to the interaction demand of massive bulletin boards in a BIM scene.

Description

Technical Field

[0001] This application relates to the field of graphics processing technology, and in particular to a method and system for interactive bulletin board picking based on group coding. Background Technology

[0002] In BIM scenarios, numerous vector elements such as annotations and anchor points appear to identify the status information of components. Since the number of components is often large, the number of these vector elements is also large. These vector elements can be rendered using screen-facing bulletin board rectangles, with each anchor point corresponding to one bulletin board rectangle. To improve rendering efficiency, all rectangles need to be merged into a batch and rendered to the screen at once. However, for mouse click picking of a massive number of rectangles, it is often necessary to redraw all rectangles into a 1x1 probe texture and then obtain which rectangle was clicked from the texture. When there is massive anchor point data, real-time anchor point picking will cause significant performance overhead.

[0003] Therefore, there is an urgent need for a bulletin board interactive picking method and system based on group coding to solve the above problems. Summary of the Invention

[0004] The purpose of this application is to provide a bulletin board interactive picking method based on group coding, including the following steps:

[0005] Divide the bulletin boards B1 to Bn into at most 256 groups, each group containing consecutively numbered bulletin boards, and the number of bulletin boards in each group is n / 256.

[0006] Draw bulletin board B1 to Bn into texture T0, where the R, G, and B channels output color information, and the A channel outputs the group ID information to which the bulletin board belongs;

[0007] Draw n / 256 dynamic bulletin boards. In the vertex shader, sample the A channel of the selected pixel in texture T0 and obtain the group ID to which the current dynamic bulletin board belongs as a basis. Based on the relative number Rel of the dynamic bulletin board, where the value of Rel ranges from 0 to n / 256, calculate the absolute bulletin board ID as the product of the group ID and the number of bulletin boards in each group plus the relative number.

[0008] Based on the absolute billboard ID, use the corresponding billboard position information in the vertex shader to render the absolute billboard ID into a 1x1 pixel;

[0009] The absolute bulletin board ID is retrieved from the 1x1 pixel and sent to the CPU to complete the selection operation.

[0010] Furthermore, the step of dividing the bulletin boards B1 to Bn into at most 256 consecutive groups, each group containing consecutively numbered bulletin boards, and the number of bulletin boards in each group being n / 256, includes:

[0011] Get the total number n of all bulletin boards in the scene, and determine the number of groups g, where g is a positive integer not greater than 256, and the value of g is dynamically adjusted according to the size of n;

[0012] Divide bulletin boards B1 to Bn into g groups in numerical order. Each group contains m bulletin boards, where m is calculated by taking n and dividing by g and rounding up. This ensures that all bulletin boards are completely allocated to each group and that the bulletin board numbers within each group are consecutive.

[0013] Assign a unique group ID to each group. The group ID ranges from 0 to g-1, and the group ID corresponds to the order of the groups. That is, the group ID of the i-th group is i-1, where i is the group number.

[0014] A group mapping table is stored in memory, recording the start number, end number, and group ID of each bulletin board group, for quick lookup during subsequent rendering and picking operations;

[0015] By grouping operations, the problem of picking up massive bulletin boards is decomposed into two stages: group-level picking and intra-group picking.

[0016] Furthermore, the step of drawing bulletin board B1 to Bn into texture T0, wherein the R, G, and B channels output color information and the A channel outputs the group ID information to which the bulletin board belongs, includes:

[0017] Set the rendering target texture T0, whose pixel format is RGBA8, where the R, G, and B channels are used to store the color information of the bulletin board, and the A channel is used to store the group ID information to which the bulletin board belongs;

[0018] In the vertex shader, screen space coordinates and texture coordinates are calculated for each bulletin board rectangle, and the group ID is passed to the fragment shader as a vertex attribute.

[0019] In the fragment shader, the color values ​​of the bulletin board are output to the R, G, and B channels according to the vertex attributes, and the group ID values ​​are normalized to the range of 0 to 1 and then output to the A channel.

[0020] Using batch rendering technology, all bulletin board B1 to Bn are drawn into texture T0 at once, ensuring that color information and group ID information are updated synchronously;

[0021] After rendering is complete, the A channel of each pixel in texture T0 stores the group ID to which the corresponding bulletin board belongs.

[0022] Furthermore, the step of calculating the absolute bulletin board ID as the product of the group ID and the number of bulletin boards in each group, plus the relative number, includes:

[0023] Based on the number of groups g and the number of bulletin boards in each group m, the number of dynamic bulletin boards to be drawn is determined to be m, where m is the integer part of n divided by g;

[0024] In the vertex shader, the A channel of the selected pixel in texture T0 is sampled by the texture sampling function to obtain the base group ID value, where the base is an integer with a value range from 0 to g-1;

[0025] Assign a relative number Rel to each dynamic bulletin board. The value of Rel ranges from 0 to m-1, representing the local sequence number of the bulletin board within the group.

[0026] Based on the group ID base and the number of bulletin boards per group m, calculate the product of the group ID and the number of bulletin boards per group to obtain the base value;

[0027] The base value is added to the relative number Rel to obtain the absolute bulletin board ID, and the absolute bulletin board ID is passed as a vertex attribute to the subsequent rendering stage to locate the position information of the specific bulletin board.

[0028] Furthermore, the step of rendering the absolute billboard ID to a 1x1 pixel using the corresponding billboard position information in the vertex shader based on the absolute billboard ID includes:

[0029] Based on the absolute bulletin board ID, retrieve the position coordinates of the corresponding bulletin board in the world coordinate system from the pre-stored bulletin board position data;

[0030] In the vertex shader, the billboard position coordinates are converted to screen space coordinates, and their offset relative to the selected pixel is calculated.

[0031] Set the rendering target to a 1x1 pixel texture, and use an orthographic projection matrix to project the bulletin board rectangle onto that pixel area;

[0032] In the fragment shader, the absolute bulletin board ID is output as a color value to the 1x1 texture, where the ID value is encoded as an integer in RGBA format;

[0033] By using depth testing and transparency blending, we ensure that the bulletin board ID closest to the camera is preserved in the 1x1 texture.

[0034] Furthermore, the step of obtaining the rendered absolute bulletin board ID from the 1x1 pixel to the CPU and completing the selection operation includes:

[0035] Read pixel data from a 1x1 pixel texture from the GPU and obtain the absolute bulletin board ID value for rendering;

[0036] Decode the ID value from RGBA format to an integer and verify the validity of the ID to ensure that the ID is within the range of bulletin board numbers;

[0037] The decoded absolute bulletin board ID is transferred to the CPU memory via the CPU-GPU data transfer interface;

[0038] In the CPU, the corresponding bulletin board attribute information, including location, color, and status data, is queried based on the absolute bulletin board ID;

[0039] After the selection is completed, an interaction event is triggered, and the picked-up bulletin board information is passed to the application for further processing.

[0040] Furthermore, this application also discloses a bulletin board interaction picking system based on block coding, including:

[0041] The grouping module is used to divide the bulletin boards B1 to Bn into up to 256 consecutive equal groups, each group containing consecutively numbered bulletin boards, and the number of bulletin boards in each group is n / 256.

[0042] The drawing module is used to draw bulletin board B1 to Bn into texture T0, where the R, G, and B channels output color information, and the A channel outputs the group ID information to which the bulletin board belongs;

[0043] The calculation module is used to draw n / 256 dynamic bulletin boards. In the vertex shader, the A channel of the selected pixel in texture T0 is sampled to obtain the group ID to which the current dynamic bulletin board belongs as a basis. Based on the relative number Rel of the dynamic bulletin board, where the value of Rel ranges from 0 to n / 256, the absolute bulletin board ID is calculated as the product of the group ID and the number of bulletin boards in each group plus the relative number.

[0044] The rendering module is used to render the absolute billboard ID into a 1x1 pixel using the corresponding billboard position information in the vertex shader;

[0045] The selection module is used to retrieve the absolute bulletin board ID from the 1x1 pixel to the CPU and complete the selection operation.

[0046] Furthermore, the rendering module includes:

[0047] The query unit is used to query the position coordinates of the corresponding bulletin board in the world coordinate system from the pre-stored bulletin board position data based on the absolute bulletin board ID;

[0048] The computation unit is used in the vertex shader to convert the billboard position coordinates into screen space coordinates and calculate their offset relative to the selected pixel.

[0049] The projection unit is used to set the texture with a rendering target of 1x1 pixels and to project the billboard rectangle onto this pixel area using an orthographic projection matrix.

[0050] The output unit is used in the fragment shader to output the absolute bulletin board ID as a color value to a 1x1 texture, where the ID value is encoded as an integer in RGBA format;

[0051] Retention units are used to ensure that the bulletin board ID closest to the camera is retained in the 1x1 texture through depth testing and transparency blending.

[0052] This application also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the above-described bulletin board interactive picking method based on block coding.

[0053] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the above-described bulletin board interactive picking method based on block coding.

[0054] The beneficial effects of this application are as follows:

[0055] This application optimizes the information storage method of texture channels by grouping and encoding bulletin boards, and completes the selection and recognition of bulletin boards in stages, thereby achieving efficient interactive picking in massive bulletin board scenarios. While ensuring picking accuracy, it reduces GPU pixel fill rate consumption and rendering performance consumption. Attached Figure Description

[0056] Figure 1 This is a schematic diagram of a method flow proposed in an embodiment of this application.

[0057] Figure 2 This is a schematic diagram of the system structure proposed in one embodiment of this application.

[0058] Figure 3 This is a schematic diagram of the internal structure of a computer device according to an embodiment of this application.

[0059] The realization of the purpose, functional features and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0060] It should be understood that the specific embodiments described herein are merely illustrative of this application and are not intended to limit this application.

[0061] like Figure 1 As shown, this application provides a bulletin board interactive picking method based on group coding, including the following steps:

[0062] S1, divide the bulletin boards B1 to Bn into at most 256 groups, each group contains consecutively numbered bulletin boards, and the number of bulletin boards in each group is n / 256;

[0063] S2, draw bulletin board B1 to Bn into texture T0, where the R, G, and B channels output color information, and the A channel outputs the group ID information to which the bulletin board belongs;

[0064] S3, draw n / 256 dynamic bulletin boards. In the vertex shader, sample the A channel of the selected pixel in texture T0, obtain the group ID to which the current dynamic bulletin board belongs as a basis, and calculate the absolute bulletin board ID based on the relative number Rel of the dynamic bulletin board, where the value of Rel ranges from 0 to n / 256. The absolute bulletin board ID is the product of the group ID and the number of bulletin boards in each group, plus the relative number.

[0065] S4. Based on the absolute billboard ID, use the corresponding billboard position information in the vertex shader to render the absolute billboard ID into a 1x1 pixel.

[0066] S5 retrieves the absolute bulletin board ID from the 1x1 pixel and transfers it to the CPU to complete the selection operation.

[0067] As described in steps S1-S5 above, this application optimizes the information storage method of texture channels by grouping and encoding the bulletin board, and completes the selection and recognition of the bulletin board in stages, thereby achieving efficient interactive picking in a massive bulletin board scene. While ensuring picking accuracy, it reduces GPU pixel fill rate consumption and rendering performance consumption.

[0068] In BIM scenarios, there are a large number of bulletin board rectangles used to identify the status of components. To improve rendering efficiency, all bulletin boards need to be merged into a batch and rendered to the screen at once. However, the mouse click picking of a large number of bulletin boards requires accurate identification of the selected bulletin board ID. This requires the rapid positioning of the target bulletin board after batch rendering, which must ensure picking accuracy while avoiding additional performance loss.

[0069] In traditional solutions, most require rendering the bulletin board twice, which can cause serious performance overhead with massive amounts of data. While there are solutions that render only once, they require additional 32-bit texture storage for the bulletin board ID, doubling the GPU pixel fill rate. This solution integrates the group ID into the A channel of the existing texture through group coding, and completes target recognition in two steps: group-level picking and intra-group picking. This reduces the number of rendering operations and eliminates the need for additional textures, effectively solving the performance problem of traditional solutions.

[0070] This application addresses the performance issue of selecting and picking a large number of bulletin boards (B1 to Bn) in a BIM scenario. First, the bulletin boards are continuously and equally divided into up to 256 groups (adapting to the 8-bit storage range of the A channel of texture T0). Then, all bulletin boards are drawn to texture T0 in a single batch rendering (R, G, and B channels store color information, and the A channel stores the corresponding group ID), avoiding the redundant rendering or additional texture consumption of traditional solutions. Subsequently, dynamic bulletin boards with the same number as each group are drawn. The T0-A channel of the selected pixel is sampled in the vertex shader to obtain the group ID. Combined with the relative number Rel within the group of the dynamic bulletin board, a unique absolute bulletin board ID is calculated by multiplying the group ID by the number of bulletin boards in each group and adding Rel. Then, the corresponding bulletin board position information is called based on the absolute ID, and it is rendered to a 1x1 pixel (focusing on the target selection, reducing GPU computation). Finally, the CPU reads the absolute ID from the 1x1 pixel to complete the selection and picking. The entire process, through two stages of group-level positioning and intra-group positioning, ensures accurate picking while reducing GPU pixel fill rate consumption and rendering load.

[0071] In one embodiment, the step of dividing the bulletin boards B1 to Bn into at most 256 consecutive groups, each group containing consecutively numbered bulletin boards, and the number of bulletin boards in each group being n / 256, includes:

[0072] S11, obtain the total number n of all bulletin boards in the scene, and determine the number of groups g, where g is a positive integer not greater than 256, and the value of g is dynamically adjusted according to the size of n to ensure that the number of bulletin boards in each group is evenly distributed;

[0073] S12, divide the bulletin boards B1 to Bn into g groups in numerical order, with each group containing m bulletin boards. The m is calculated by taking n and dividing by the floor value of g, ensuring that all bulletin boards are completely allocated to each group and that the bulletin board numbers in each group are consecutive.

[0074] S13, assign a unique group ID to each group. The group ID ranges from 0 to g-1, and the group ID corresponds to the order of the groups. That is, the group ID of the i-th group is i-1, where i is the group number.

[0075] S14, store the group mapping table in memory, record the start number, end number and group ID of each bulletin board group, for quick lookup in subsequent rendering and picking operations;

[0076] S15, through grouping operations, decomposes the problem of picking up massive bulletin boards into two stages: group-level picking and intra-group picking, thereby reducing the pixel fill rate consumption of the GPU.

[0077] As described in steps S11-S15 above, by obtaining the total number of bulletin boards in the BIM scene and dynamically determining the number of groups not exceeding 256, the bulletin boards are divided into corresponding groups continuously and evenly according to their numbers. A unique group ID is assigned to each group and a group mapping table is established. Finally, the problem of picking up a large number of bulletin boards is decomposed into two stages: group-level picking and intra-group picking, thereby achieving the goal of reducing GPU pixel fill rate consumption.

[0078] In BIM scenarios, the number of bulletin boards (vector elements) used to identify component status is usually massive (i.e., the total number of bulletin boards n is large). In subsequent picking operations, the group ID needs to be stored in the A channel of texture T0. This channel is in 8-bit format and can only store values ​​from 0 to 255. Therefore, the number of groups must be controlled to no more than 256. At the same time, if the number of bulletin boards in each group is unevenly distributed, it will lead to excessive picking load in some groups and waste of resources in some groups, affecting the overall picking efficiency. Therefore, it is necessary to dynamically adjust the number of groups and distribute bulletin boards evenly to adapt to the storage limit of the A channel and ensure the efficiency of subsequent picking.

[0079] Obtain the total number n of all bulletin boards in the scene and determine the number of groups g. n is obtained by counting the number of bulletin boards corresponding to all vector elements used to identify component status within the BIM scene. g is a positive integer no greater than 256 and needs to be dynamically adjusted according to the size of n. This dynamic adjustment ensures a uniform distribution of bulletin board numbers in each group, avoiding concentrated load. Divide bulletin boards B1 to Bn into g groups sequentially according to their numbers. Each group contains m bulletin boards, calculated by taking the integer part of g divided by n. Simultaneously, ensure that the bulletin board numbers within each group are consecutive. For example, group ID 0 contains B1 to B2, group ID 1 contains B3 to B4, and so on, ensuring that the group to which a bulletin board belongs can be quickly located by its number. Then, a unique group ID is assigned to each group. The group ID ranges from 0 to g-1 and corresponds to the order of the groups. That is, the group ID of group 1 is 0, the group ID of group 2 is 1, and so on, up to the group ID of group g-1. This setting allows the group ID to directly adapt to the storage range of the A channel of texture T0 without additional format conversion, reducing computation time. A group mapping table is stored in memory. This mapping table records the start number, end number, and group ID of each bulletin board group. For example, the group with group ID 0 has a start number of 1 and an end number of 2, and the group with group ID 1 has a start number of 3 and an end number of 4. During subsequent rendering, the group ID of any bulletin board can be quickly looked up through this mapping table without real-time calculation. During picking, the bulletin board range of the corresponding group can also be quickly located by the group ID, further improving operational efficiency. By performing the above grouping operation, the original problem of picking up n bulletin boards at once is broken down into two stages: first, locating the group by group ID (group-level picking), and then locating the specific bulletin board within the group (intra-group picking). The number of bulletin boards processed each time is reduced from n to m per group, which significantly reduces the amount of data that the GPU needs to process during the picking process, thereby reducing the GPU's pixel fill rate consumption.

[0080] In one embodiment, the step of drawing bulletin board B1 to Bn into texture T0, wherein the R, G, and B channels output color information and the A channel outputs the group ID information to which the bulletin board belongs, includes:

[0081] S21, set the rendering target texture T0, whose pixel format is RGBA8, where the R, G, and B channels are used to store the color information of the bulletin board, and the A channel is used to store the group ID information to which the bulletin board belongs;

[0082] S22, in the vertex shader, calculate the screen space coordinates and texture coordinates for each bulletin board rectangle, and pass the group ID as a vertex attribute to the fragment shader;

[0083] S23, In the fragment shader, the color value of the bulletin board is output to the R, G, and B channels according to the vertex attributes. At the same time, the group ID value is normalized to the range of 0 to 1 and then output to the A channel.

[0084] S24, using batch rendering technology, all bulletin board B1 to Bn are drawn into texture T0 at once, ensuring that color information and group ID information are updated synchronously;

[0085] S25, after rendering is complete, the A channel of each pixel of texture T0 stores the group ID to which the corresponding bulletin board belongs, providing a group-level identifier for subsequent interactive picking.

[0086] As described in steps S21-S25 above, by setting the rendering target texture T0 with pixel format RGBA8, during the batch rendering of bulletin boards B1 to Bn, the color information is stored in the R, G, and B channels of T0, and the group ID to which the bulletin board belongs is stored in the A channel of T0. This achieves the synchronous completion of color rendering and group ID storage, while avoiding the use of additional textures and reducing GPU pixel fill rate consumption.

[0087] In BIM scenarios, bulletin boards need to simultaneously meet the requirements of visual presentation and interactive picking. Visual presentation requires outputting color information, while interactive picking requires obtaining the group ID to which the bulletin board belongs to locate the group. In traditional solutions, color and picking identifiers need to be processed separately, which consumes more GPU resources. In addition, the A channel of T0 is in 8-bit format, and its value range of 0 to 1 can be adapted to the group ID range of 0 to 255 through normalization, without the need for additional channel bit expansion. Therefore, the A channel of T0 can be reused to store the group ID, and both requirements can be completed simultaneously in a single rendering, reducing resource waste.

[0088] The rendering target texture T0 is set, and its pixel format is determined to be RGBA8. In this format, the R, G, and B channels each occupy 8 bits, which can meet the storage requirements of billboard color information. The A channel also occupies 8 bits, and its value range of 0 to 1 can be adapted to the group ID range of 0 to 255 through normalization. Group ID storage can be achieved without creating an additional texture, reducing the GPU texture resource consumption. In the vertex shader, screen space coordinates and texture coordinates are calculated for each billboard rectangle. The screen space coordinates are used to determine the display position of the billboard on the screen, and the texture coordinates are used for color sampling in the subsequent fragment shader. At the same time, the group ID to which the current billboard belongs is read from the established group mapping table and passed as a vertex attribute to the fragment shader to ensure that the group ID corresponds one-to-one with the billboard. In the fragment shader, based on the color data passed from the vertex attributes, the color values ​​of the bulletin boards are output to the R, G, and B channels of T0. Simultaneously, the group IDs are normalized (e.g., when the group ID is 5, the normalization value is 5 / 255), and the normalized value is output to the A channel of T0. This process adapts the group IDs to the 0-1 value range of the A channel, allowing subsequent sampling to reconstruct the group IDs by reverse calculation (normalized value × 255). Batch rendering technology is used to draw all bulletin boards B1 to Bn into texture T0 at once. For example, when the total number of bulletin boards n is 1024, batch rendering is unnecessary; all bulletin boards can be drawn with a single rendering command. This ensures that the color information and group ID information of each bulletin board are synchronously updated to the corresponding pixels in T0, avoiding performance loss caused by multiple renderings. After rendering, each pixel of texture T0 corresponds to a bulletin board, and its A channel stores the normalized value of the group ID to which the bulletin board belongs. During subsequent interactive picking, it is only necessary to sample the A channel value corresponding to the selected pixel and restore it to the group ID to quickly obtain the group to which the bulletin board belongs. This provides a key group-level identifier for subsequent calculation of the absolute bulletin board ID without the need for additional query or rendering operations, further improving picking efficiency.

[0089] In one embodiment, the step of calculating the absolute bulletin board ID as the product of the group ID and the number of bulletin boards in each group, plus the relative number, includes:

[0090] S31. Based on the number of groups g and the number of bulletin boards in each group m, determine the number of dynamic bulletin boards to be drawn as m, where m is the integer part of n divided by g;

[0091] S32, in the vertex shader, the A channel of the selected pixel in texture T0 is sampled by the texture sampling function to obtain the group ID value basis, where the basis is an integer and the value range is from 0 to g-1;

[0092] S33, assign a relative number Rel to each dynamic bulletin board. The value of Rel ranges from 0 to m-1, representing the local sequence number of the bulletin board within the group;

[0093] S34. Based on the group ID base and the number of bulletin boards in each group m, calculate the product of the group ID and the number of bulletin boards in each group to obtain the base value;

[0094] S35 adds the base value to the relative number Rel to obtain the absolute bulletin board ID, and passes the absolute bulletin board ID as a vertex attribute to the subsequent rendering stage to locate the position information of the specific bulletin board.

[0095] As described in steps S31-S35 above, the number of dynamic bulletin boards to be drawn is determined by the number of groups and the number of bulletin boards in each group. The group ID is obtained by sampling texture T0 in the vertex shader. A relative number within the group is assigned to the dynamic bulletin board. The absolute bulletin board ID is then calculated by combining the product of the group ID and the number of bulletin boards in each group with the relative number. This achieves accurate positioning of specific bulletin boards within the group and provides a key identifier for rendering the absolute ID to 1x1 pixels in the future. At the same time, it avoids excessive GPU load caused by directly processing a large number of bulletin board IDs.

[0096] In the BIM scenario, after grouping operations, the group ID has been stored in the A channel of texture T0, completing group-level picking. However, to pick up specific bulletin boards, it is necessary to determine the corresponding bulletin board number within the group. Since the number of bulletin boards in each group is m, the bulletin boards within the group need to be distinguished by local serial numbers (relative numbers Rel). Furthermore, the group ID and relative number need to be combined to generate a unique absolute bulletin board ID, which can uniquely identify any bulletin board in the scene. At the same time, the number of dynamic bulletin boards needs to be consistent with the number of bulletin boards in each group m to cover all bulletin boards within the group and ensure no omissions or redundant calculations. Therefore, the above steps are required to achieve intra-group positioning and absolute ID generation.

[0097] Based on the number of groups (g) and the number of bulletin boards per group (m), the number of dynamic bulletin boards to be drawn is determined to be m, where g and m are derived from the grouping results. For example, when the total number of bulletin boards n=1024 and the number of groups g=256, m is the integer part of n divided by g, which is 4. Therefore, the number of dynamic bulletin boards is determined to be 4. This number is consistent with the number of bulletin boards per group, which can completely cover all bulletin boards within the group, avoiding resource waste caused by missing bulletin boards within the group or having an excessive number of dynamic bulletin boards. Next, in the vertex shader, the A channel of the selected pixel in texture T0 is sampled using the texture sampling function. Texture T0 comes from the above rendering results, and its A channel stores the normalized group ID. After sampling, the normalized value needs to be restored to an integer (e.g., when the A channel value is 5 / 255, it is restored to the integer 5) to obtain the base group ID value. The value range of this base value is 0 to g-1 (here g=256, so the range is 0 to 255), ensuring the accuracy of the group ID. Then, each dynamic bulletin board is assigned a relative number Rel, with a value ranging from 0 to m-1 (here, m=4, so the range is 0 to 3). Rel represents the local sequence number of the dynamic bulletin board within the group. For example, Rel=0 corresponds to the first bulletin board in the group, and Rel=3 corresponds to the fourth bulletin board in the group. Different bulletin boards within the group can be distinguished by Rel. Next, a base value is calculated based on the group ID and the number of bulletin boards in each group, m. The base value is the product of the group ID and m. For example, when the group ID base = 5 and m = 4, the base value = 5 × 4 = 20. The base value can locate the starting absolute ID of the first bulletin board in the group (for a group with group ID = 5, the absolute ID of the first bulletin board is 20). The absolute bulletin board ID is obtained by adding the base value to the relative number Rel. For example, when the base value is 20 and Rel is 2, the absolute bulletin board ID is 20 + 2 = 22. This ID uniquely corresponds to the bulletin board numbered B23 in the scene. At the same time, the absolute bulletin board ID is passed as a vertex attribute to the subsequent rendering stage. This provides a precise identification basis for calling the bulletin board position information based on the absolute ID and rendering it to a 1x1 pixel, ensuring that subsequent picking operations can accurately locate the specific bulletin board.

[0098] In one embodiment, the step of rendering the absolute bulletin board ID to a 1x1 pixel using the corresponding bulletin board position information in the vertex shader based on the absolute bulletin board ID includes:

[0099] S41, based on the absolute bulletin board ID, query the position coordinates of the corresponding bulletin board in the world coordinate system from the pre-stored bulletin board position data;

[0100] S42, in the vertex shader, converts the billboard position coordinates to screen space coordinates and calculates their offset relative to the selected pixel;

[0101] S43, set the rendering target to a 1x1 pixel texture, and use an orthographic projection matrix to project the bulletin board rectangle onto that pixel area;

[0102] S44, in the fragment shader, outputs the absolute bulletin board ID as a color value to the 1x1 texture, where the ID value is encoded as an integer in RGBA format;

[0103] The S45, through depth testing and transparency blending, ensures that the bulletin board ID closest to the camera is preserved in the 1x1 texture, enabling accurate pickup.

[0104] As described in steps S41-S45 above, the world coordinate system position coordinates of the corresponding bulletin board are queried through the absolute bulletin board ID, converted into screen space coordinates, and the offset from the selected pixel is calculated. Then, with a 1x1 pixel texture as the rendering target, the bulletin board rectangle is projected onto the pixel area through an orthogonal projection matrix. The absolute ID is encoded into RGBA format and output. Finally, the bulletin board ID closest to the camera is retained through depth testing and transparency mixing, so as to achieve accurate rendering of the absolute bulletin board ID in 1x1 pixels. This provides accurate identification data for the CPU to read the ID and complete the point picking, while reducing the rendering range to reduce the GPU computing load.

[0105] In a BIM scenario, after calculating the absolute bulletin board ID, it is necessary to further locate the spatial position of the bulletin board and focus its ID on the selected pixel area. The selection operation targets a specific pixel on the screen, so only the bulletin board ID corresponding to that pixel needs to be rendered, without rendering all bulletin boards. Therefore, setting a 1x1 pixel texture as the rendering target can significantly reduce the amount of data rendered by the GPU. At the same time, bulletin boards in the scene may overlap spatially, and the bulletin board closest to the camera is the target that the user actually selects. It is necessary to filter through depth testing to avoid picking errors. Therefore, the above steps are required to achieve accurate ID rendering and target filtering.

[0106] The world coordinates of the corresponding bulletin board are retrieved from the pre-stored bulletin board location data based on the absolute bulletin board ID. This pre-stored data is generated during BIM scene initialization, assigning world coordinates to each bulletin board (B1 to Bn) and storing it in memory. For example, if the absolute bulletin board ID is 22 (corresponding to bulletin board B23), the retrieved world coordinates are (X=10.2, Y=5.6, Z=3.8). This one-to-one correspondence between the absolute ID and the location data allows for quick positioning of the bulletin board without real-time coordinate calculation. Next, in the vertex shader, the world coordinates of the bulletin board are converted to screen space coordinates based on the main camera's intrinsic parameters (such as focal length and pixel size) and extrinsic parameters (such as camera position and pose). The offset between these screen space coordinates and the selected pixel coordinates is then calculated. Here, the offset is 0 to ensure precise alignment between the bulletin board coordinates and the selected pixel, preventing rendering offsets that could lead to ID reading errors. Next, the rendering target is set to a 1x1 pixel texture. This texture contains only one pixel, and only the bulletin board corresponding to the selected location needs to be rendered, without processing other areas, significantly reducing the GPU rendering load. At the same time, an orthographic projection matrix is ​​used to project the bulletin board rectangle onto this 1x1 pixel area. The orthographic projection matrix can maintain the shape and size ratio of the bulletin board, avoid the distortion caused by perspective projection, and ensure that the bulletin board rectangle completely covers the 1x1 pixel, so that the ID can be completely rendered to this pixel. In the fragment shader, the absolute bulletin board ID is encoded as an integer in RGBA format and output to the 1x1 texture. Since the four channels of the RGBA8 format are 32 bits in total, they can completely store the absolute ID of integer type. For example, if the absolute ID is 22, its binary value is split into the four RGBA channels, with each channel storing 8 bits of data, ensuring that the ID does not lose information in the texture and can be accurately restored. Through depth testing and transparency blending, the depth test compares the current bulletin board's depth value (distance from the camera) with other potentially overlapping bulletin boards, retaining the bulletin board ID with the smallest depth value (i.e., closest to the camera). Transparency blending avoids pixel interference from non-target bulletin boards. For example, if bulletin boards B23 and B24 overlap, with B23 having a depth value of 3.8 and B24 having a depth value of 4.5, the depth test only retains the ID of B23, ensuring that the 1x1 texture stores the actual bulletin board ID selected by the user, thus achieving the basis for accurate picking.

[0107] In one embodiment, the step of obtaining the rendered absolute bulletin board ID from the 1x1 pixel to the CPU and completing the selection operation includes:

[0108] S51 reads pixel data from a 1x1 pixel texture from the GPU and obtains the absolute bulletin board ID value for rendering;

[0109] S52 decodes the ID value from RGBA format to an integer and verifies the validity of the ID to ensure that the ID is within the range of bulletin board numbers;

[0110] S53 transmits the decoded absolute bulletin board ID to CPU memory via the CPU-GPU data transfer interface;

[0111] S54, in the CPU, queries the corresponding bulletin board attribute information based on the absolute bulletin board ID, including location, color and status data;

[0112] S55, after the selection operation is completed, triggers an interaction event, and passes the picked-up bulletin board information to the application for further processing.

[0113] As described in steps S51-S55 above, the absolute bulletin board ID stored in the 1x1 pixel texture is read from the GPU, decoded from RGBA format into an integer and its validity is verified, and then transmitted to the CPU memory through the CPU-GPU data transmission interface. The CPU queries the bulletin board attribute information corresponding to the ID, and finally triggers an interaction event to pass the picked information to the application, completing the closed loop of the entire selection operation. This ensures that the picking results are accurately and efficiently fed back to the application level, realizing the complete function of bulletin board interactive picking in the BIM scene.

[0114] In a BIM scenario, after the above processing, the absolute ID of the bulletin board closest to the camera has been rendered and stored in a 1x1 pixel texture. However, this ID is currently located in GPU memory, while the application's logic processing depends on the CPU. The ID data in the GPU needs to be transferred to the CPU. At the same time, the ID stored in the GPU is in RGBA encoding format, which cannot be directly recognized and used by the CPU. Furthermore, there may be invalid IDs due to rendering anomalies. Direct use would cause application processing errors. Therefore, it is necessary to achieve effective connection between GPU data and CPU application through the steps of reading, decoding, verifying, transmitting, querying, and triggering events to complete the final implementation of the selection operation.

[0115] Traditional technical solutions require transmitting either the entire data of a 1x1 probe texture (though 1x1, decoding and verification are not optimized) or the entire data of a 32-bit texture T1. Both suffer from relatively large data transmission volumes or lack of validity verification. The first solution lacks optimization for the ID decoding process, potentially leading to reading errors due to format mismatches. The second solution transmits the entire texture data; even if only a single ID is needed, it still requires processing a large amount of redundant data, resulting in low transmission efficiency. Furthermore, neither solution verifies ID validity, easily transmitting invalid IDs to the CPU and causing application anomalies. To address this issue, this solution reads only a single ID data of a 1x1 pixel (a very small data volume), adds decoding and validity verification steps, and then transmits it to the CPU through an efficient interface, specifically solving the transmission efficiency and data accuracy problems of traditional solutions.

[0116] The pixel data of a 1x1 pixel texture is read from the GPU to obtain the absolute bulletin board ID value for rendering. The rendering target set above for this 1x1 pixel texture only stores the RGBA format data corresponding to the bulletin board ID closest to the camera. When reading, the RGBA channel data of the pixel is directly extracted through the GPU texture reading interface (such as the texture data reading function in the graphics API). For example, the RGBA data read corresponds to the encoded absolute bulletin board ID=22. Since only 4 bytes of data (RGBA8 format) of a single pixel are read, the amount of data read is greatly reduced compared to the traditional solution of transmitting the entire texture, which significantly improves the reading efficiency.

[0117] The ID value is decoded from RGBA format to an integer and its validity is verified. The decoding process is performed in reverse according to the ID encoding rules. The absolute ID is split into four 8-bit channels of RGBA in integer form and stored. During decoding, the combination is calculated according to the channel weights. The validity verification requires comparing the decoded ID with the total number of bulletin boards n (n comes from the total number of scene bulletin boards obtained, such as n=1024) to ensure that the ID is within the range of 1 to n. If the decoded ID=1025, it is determined to be invalid to avoid data loss or errors during subsequent CPU queries and to ensure that the ID passed to the CPU is usable.

[0118] The decoded absolute bulletin board ID is transferred to CPU memory via the CPU-GPU data transfer interface. Using a standard CPU-GPU data transfer interface (such as a PCIe bus interface), the transmission latency is extremely low because only a single integer (4 bytes of data) is transmitted. Compared to traditional solutions that transmit large amounts of texture data, this significantly shortens data interaction time and ensures real-time performance of click operations. For example, when transmitting ID=22, the memory transfer from GPU to CPU can be completed in microseconds, avoiding user waiting for operation responses.

[0119] The CPU queries the corresponding bulletin board attribute information based on the absolute bulletin board ID. A bulletin board attribute table is pre-stored in the CPU memory. This table is established during BIM scene initialization, associating each absolute bulletin board ID with its corresponding location, color, and status data. This transforms the abstract ID into concrete information directly usable by the application, providing data support for subsequent interactive functions. Upon completion of a selection operation, an interaction event is triggered, transmitting the picked-up bulletin board information to the application. Based on the retrieved bulletin board attribute information, standard interaction events (such as mouse click callback events) are generated. The attribute information is encapsulated as event parameters and transmitted to the BIM application. Upon receiving the data, the application can execute preset subsequent operations (such as displaying component details on the interface and highlighting the corresponding bulletin board). For example, after transmitting bulletin board information with ID=22, the application will pop up a window on the screen displaying the component's name and status details, and highlight the bulletin board, completing the closed loop of the entire selection interaction. This ensures that the user's operational intentions are accurately and promptly responded to, realizing the practical application value of bulletin board interactive picking.

[0120] like Figure 2 As shown, this application also discloses a bulletin board interaction picking system based on block coding, including:

[0121] The grouping module is used to divide the bulletin boards B1 to Bn into up to 256 groups in a continuous sequence. Each group contains consecutively numbered bulletin boards, and the number of bulletin boards in each group is n / 256.

[0122] The drawing module is used to draw bulletin board B1 to Bn into texture T0, where the R, G, and B channels output color information, and the A channel outputs the group ID information to which the bulletin board belongs;

[0123] The calculation module is used to draw n / 256 dynamic bulletin boards. In the vertex shader, the A channel of the selected pixel in texture T0 is sampled to obtain the group ID to which the current dynamic bulletin board belongs as a basis. Based on the relative number Rel of the dynamic bulletin board, where the value of Rel ranges from 0 to n / 256, the absolute bulletin board ID is calculated as the product of the group ID and the number of bulletin boards in each group plus the relative number.

[0124] The rendering module is used to render the absolute billboard ID into a 1x1 pixel using the corresponding billboard position information in the vertex shader;

[0125] The selection module is used to retrieve the absolute bulletin board ID from the 1x1 pixel to the CPU and complete the selection operation.

[0126] In one embodiment, the rendering module includes:

[0127] The query unit is used to query the position coordinates of the corresponding bulletin board in the world coordinate system from the pre-stored bulletin board position data based on the absolute bulletin board ID;

[0128] The computation unit is used in the vertex shader to convert the billboard position coordinates into screen space coordinates and calculate their offset relative to the selected pixel.

[0129] The projection unit is used to set the texture with a rendering target of 1x1 pixels and to project the billboard rectangle onto this pixel area using an orthographic projection matrix.

[0130] The output unit is used in the fragment shader to output the absolute bulletin board ID as a color value to a 1x1 texture, where the ID value is encoded as an integer in RGBA format;

[0131] The retention unit is used to ensure that the bulletin board ID closest to the camera is captured by a combination of depth testing and transparency. This application also provides a computer device including a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement the steps of the above-described bulletin board interactive pickup method based on block coding.

[0132] like Figure 3 As shown, this application also provides a computer device, which can be a server, and its internal structure can be as follows: Figure 3 As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides computational and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The database stores all the data required for a block-coding-based bulletin board interactive pickup method. The network interface communicates with external terminals via a network connection. When the computer program is executed by the processor, it implements a block-coding-based bulletin board interactive pickup method.

[0133] Those skilled in the art will understand that Figure 3 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer equipment on which the present application is applied.

[0134] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the above-described bulletin board interactive picking method based on block coding.

[0135] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in this application and in the embodiments can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual-speed SDRAM (SSRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), RAMbus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).

[0136] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, apparatus, article, or method that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, apparatus, article, or method. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, apparatus, article, or method that includes that element.

[0137] The above description is merely a preferred embodiment of this application and does not limit the scope of this application. Any equivalent results or equivalent process transformations made based on the content of this application specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the scope of protection of this application.

Claims

1. A bulletin board interactive pickup method based on group coding, characterized in that, Includes the following steps: Divide the bulletin boards B1 to Bn into at most 256 groups, each group containing consecutively numbered bulletin boards, and the number of bulletin boards in each group is n / 256. Draw bulletin board B1 to Bn into texture T0, where the R, G, and B channels output color information, and the A channel outputs the group ID information to which the bulletin board belongs; Draw n / 256 dynamic bulletin boards. In the vertex shader, sample the A channel of the selected pixel in texture T0 and obtain the group ID to which the current dynamic bulletin board belongs as a basis. Based on the relative number Rel of the dynamic bulletin board, where the value of Rel ranges from 0 to n / 256, calculate the absolute bulletin board ID as the product of the group ID and the number of bulletin boards in each group plus the relative number. Based on the absolute billboard ID, use the corresponding billboard position information in the vertex shader to render the absolute billboard ID into a 1x1 pixel; The absolute bulletin board ID is retrieved from the 1x1 pixel and sent to the CPU to complete the selection operation.

2. The bulletin board interactive pickup method based on group coding according to claim 1, characterized in that, The step of dividing the bulletin boards B1 to Bn into at most 256 groups, each group containing consecutively numbered bulletin boards, and each group containing n / 256 bulletin boards, includes: Get the total number n of all bulletin boards in the scene, and determine the number of groups g, where g is a positive integer not greater than 256, and the value of g is dynamically adjusted according to the size of n; Divide bulletin boards B1 to Bn into g groups in numerical order. Each group contains m bulletin boards, where m is calculated by taking n and dividing by g and rounding up. This ensures that all bulletin boards are completely allocated to each group and that the bulletin board numbers within each group are consecutive. Assign a unique group ID to each group. The group ID ranges from 0 to g-1, and the group ID corresponds to the order of the groups. That is, the group ID of the i-th group is i-1, where i is the group number. A group mapping table is stored in memory, recording the start number, end number, and group ID of each bulletin board group, for quick lookup during subsequent rendering and picking operations; By grouping operations, the problem of picking up massive bulletin boards is decomposed into two stages: group-level picking and intra-group picking.

3. The bulletin board interactive pickup method based on group coding according to claim 1, characterized in that, The steps of drawing bulletin board B1 to Bn into texture T0, wherein the R, G, and B channels output color information and the A channel outputs the group ID information to which the bulletin board belongs, include: Set the rendering target texture T0, whose pixel format is RGBA8, where the R, G, and B channels are used to store the color information of the bulletin board, and the A channel is used to store the group ID information to which the bulletin board belongs; In the vertex shader, screen space coordinates and texture coordinates are calculated for each bulletin board rectangle, and the group ID is passed to the fragment shader as a vertex attribute. In the fragment shader, the color values ​​of the bulletin board are output to the R, G, and B channels according to the vertex attributes, and the group ID values ​​are normalized to the range of 0 to 1 and then output to the A channel. Using batch rendering technology, all bulletin board B1 to Bn are drawn into texture T0 at once, ensuring that color information and group ID information are updated synchronously; After rendering is complete, the A channel of each pixel in texture T0 stores the group ID to which the corresponding bulletin board belongs.

4. The bulletin board interactive pickup method based on group coding according to claim 1, characterized in that, The step of calculating the absolute bulletin board ID as the product of the group ID and the number of bulletin boards in each group, plus the relative number, includes: Based on the number of groups g and the number of bulletin boards in each group m, the number of dynamic bulletin boards to be drawn is determined to be m, where m is the integer part of n divided by g; In the vertex shader, the A channel of the selected pixel in texture T0 is sampled by the texture sampling function to obtain the base group ID value, where the base is an integer with a value range from 0 to g-1; Assign a relative number Rel to each dynamic bulletin board. The value of Rel ranges from 0 to m-1, representing the local sequence number of the bulletin board within the group. Based on the group ID base and the number of bulletin boards per group m, calculate the product of the group ID and the number of bulletin boards per group to obtain the base value; The base value is added to the relative number Rel to obtain the absolute bulletin board ID, and the absolute bulletin board ID is passed as a vertex attribute to the subsequent rendering stage to locate the position information of the specific bulletin board.

5. The bulletin board interactive pickup method based on group coding according to claim 1, characterized in that, The step of rendering the absolute billboard ID to a 1x1 pixel using the corresponding billboard position information in the vertex shader based on the absolute billboard ID includes: Based on the absolute bulletin board ID, retrieve the position coordinates of the corresponding bulletin board in the world coordinate system from the pre-stored bulletin board position data; In the vertex shader, the billboard position coordinates are converted to screen space coordinates, and their offset relative to the selected pixel is calculated. Set the rendering target to a 1x1 pixel texture, and use an orthographic projection matrix to project the bulletin board rectangle onto that pixel area; In the fragment shader, the absolute bulletin board ID is output as a color value to the 1x1 texture, where the ID value is encoded as an integer in RGBA format; By using depth testing and transparency blending, we ensure that the bulletin board ID closest to the camera is preserved in the 1x1 texture.

6. The bulletin board interactive pickup method based on group coding according to claim 1, characterized in that, The steps for obtaining the absolute bulletin board ID from the 1x1 pixel to the CPU and completing the selection operation include: Read pixel data from a 1x1 pixel texture from the GPU and obtain the absolute bulletin board ID value for rendering; Decode the ID value from RGBA format to an integer and verify the validity of the ID to ensure that the ID is within the range of bulletin board numbers; The decoded absolute bulletin board ID is transferred to the CPU memory via the CPU-GPU data transfer interface; In the CPU, the corresponding bulletin board attribute information, including location, color, and status data, is queried based on the absolute bulletin board ID; After the selection is completed, an interaction event is triggered, and the picked-up bulletin board information is passed to the application for further processing.

7. A bulletin board interactive pickup system based on group coding, characterized in that, include: The grouping module is used to divide the bulletin boards B1 to Bn into up to 256 groups in a continuous sequence. Each group contains consecutively numbered bulletin boards, and the number of bulletin boards in each group is n / 256. The drawing module is used to draw bulletin board B1 to Bn into texture T0, where the R, G, and B channels output color information, and the A channel outputs the group ID information to which the bulletin board belongs; The calculation module is used to draw n / 256 dynamic bulletin boards. In the vertex shader, the A channel of the selected pixel in texture T0 is sampled to obtain the group ID to which the current dynamic bulletin board belongs as a basis. Based on the relative number Rel of the dynamic bulletin board, where the value of Rel ranges from 0 to n / 256, the absolute bulletin board ID is calculated as the product of the group ID and the number of bulletin boards in each group plus the relative number. The rendering module is used to render the absolute billboard ID into a 1x1 pixel using the corresponding billboard position information in the vertex shader; The selection module is used to retrieve the absolute bulletin board ID from the 1x1 pixel to the CPU and complete the selection operation.

8. The bulletin board interactive pickup system based on group coding according to claim 7, characterized in that, The rendering module includes: The query unit is used to query the position coordinates of the corresponding bulletin board in the world coordinate system from the pre-stored bulletin board position data based on the absolute bulletin board ID; The computation unit is used in the vertex shader to convert the billboard position coordinates into screen space coordinates and calculate their offset relative to the selected pixel. The projection unit is used to set the texture with a rendering target of 1x1 pixels and to project the billboard rectangle onto this pixel area using an orthographic projection matrix. The output unit is used in the fragment shader to output the absolute bulletin board ID as a color value to a 1x1 texture, where the ID value is encoded as an integer in RGBA format; Retention units are used to ensure that the bulletin board ID closest to the camera is retained in the 1x1 texture through depth testing and transparency blending.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 6.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 6.

Images