A web page end triangular facet model dynamic updating method based on voxel division

Abstract

The application discloses a kind of based on voxel division's webpage end triangular facet model dynamic updating method, including steps: voxel division and coding;Triangular facet coding;Triangular facet is split by determining the positional relationship of voxel and triangular facet through voxel coding and triangular facet coding, and the split triangular facet is contained in a voxel;According to tool path foresight, the voxel that will be cut soon is screened, and hash bucket-shaped data structure is established according to voxel and triangular facet coding;According to the tool position information that edge end simulation returns in real time, the intersecting voxel with tool is screened, webpage end reads the coding of the intersecting voxel, and all triangular facets under the corresponding node in hash bucket are deleted;According to the newly generated triangular facet after tool cutting obtained by edge end simulation, coding and storage are carried out to hash bucket node;Render display updated triangular facet, realize webpage end geometric simulation.The method can realize the efficient update of workpiece model when cutting simulation is carried out in webpage end.

Description

Technical Field

[0001] This invention belongs to the field of intelligent manufacturing CNC machining, and relates to cutting simulation methods, specifically a dynamic update method for web-based triangular facet models based on voxel partitioning. Background Technology

[0002] Precise and efficient cutting simulation methods have always been one of the core technologies of intelligent CNC machining, and also a core requirement for related industrial software in China. Real-time online cutting simulation places higher demands on efficiency and accuracy compared to traditional offline simulation.

[0003] Real-time simulation places high demands on a computer's CPU, graphics card, and memory. Therefore, most simulation processes rely on local high-performance computers for calculations and rendering, meaning the simulation results are only visible to on-site personnel. However, the intelligent development of CNC machining requires remote simulation, allowing non-local computers to observe the machining simulation in real time. Thus, moving the simulation process to the cloud becomes crucial for intelligentization. Chinese invention patent application CN201811146285.4 discloses a cutting simulation implementation method for real-time machining monitoring, using a binary tree data structure to improve model storage and retrieval, but it remains limited to local simulation. Chinese invention patent application CN202110899400.0 discloses an efficient geometric simulation method for cutting processes based on VBO, largely solving the efficiency problem of online geometric simulation and laying the foundation for cloud simulation, but it does not implement model updates on the web page. Although the accuracy and efficiency of local simulation calculations are guaranteed, data transmission efficiency and web page rendering efficiency still pose challenges for cloud simulation. If each frame of the model result from the local simulation is directly uploaded to the cloud for rendering and display, it will not only require a huge amount of network bandwidth, but will also inevitably cause lag or even page crashes for ordinary users' computers.

[0004] In summary, existing real-time online simulation methods are limited to local operation and cannot enable simultaneous viewing of the simulation process across multiple machines in different locations. Furthermore, existing geometric simulation methods suffer from large data footprints and low transmission efficiency. To achieve real-time simulation on a web-based platform, it is crucial to optimize the storage methods for model data, the edge-cloud data transmission methods, and the web-based model rendering methods to meet the demands for real-time efficiency. Summary of the Invention

[0005] Against the above background, this invention provides a method for dynamically updating a triangular patch model on a web-based platform based on voxel partitioning. By using voxel lookup and triangular patch precoding, the workpiece model is dynamically partitioned. A method for efficiently adding, deleting, modifying, and querying triangular patch model data is designed to achieve efficient updating of the workpiece model during web-based cutting simulation. This invention adopts the following technical solution:

[0006] A method for dynamically updating a web-based triangular patch model based on voxel partitioning includes the following steps:

[0007] S1, Voxel division and coding: Divide the blank 3D model into voxels and code each voxel;

[0008] S2, Triangular facet encoding: Read in the blank triangular facet model and encode the triangular facet;

[0009] S3, Triangular facet segmentation: The positional relationship between voxels and triangular facets is determined by voxel encoding and triangular facet encoding. If a triangular facet is completely contained within a voxel, it does not need to be segmented; otherwise, the triangular facets spanning voxels are segmented along the voxel boundary to obtain segmented triangular facets, all of which are contained within a voxel.

[0010] S4, Prepare data: Based on the toolpath look-ahead, select the voxels that will be cut, and use the code of each voxel to be cut as a node. Place a linked list containing the triangular facet code in the node to establish a hash bucket data structure.

[0011] S5, Dynamic Update of Triangular Facets: Based on the tool position information transmitted back in real time from the edge simulation, voxels intersecting with the tool are filtered, the code of the intersecting voxels is read on the web page, and all triangular faces under the corresponding node in the hash bucket are deleted; based on the newly generated triangular faces obtained after the tool cutting by the edge simulation, the newly generated triangular faces are encoded and stored under the hash bucket node.

[0012] S6, Visual Rendering: Renders and displays the updated triangular facets, enabling geometric simulation on the web page.

[0013] Furthermore, step S1 specifically includes:

[0014] The rough 3D model is divided into several voxels. Each voxel is encoded using 21 bits based on the number of meshes arranged in the x, y, and z directions to obtain a unique vID code.

[0015] vID = x * 2 14 +y*2 7 +z

[0016] Where x, y, and z represent the number of grids arranged in the three-dimensional direction of the voxels.

[0017] Furthermore, step S2 includes the following sub-steps:

[0018] S2.1, Vertex encoding of a triangle facet, where the vertex coordinates are x. m y m zm For a voxel with side length l, the code of the vertex is the code of the voxel it belongs to, calculated by the following formula:

[0019] vID = i * 2 14 +j*2 7 +k

[0020] in,

[0021] i = x m / l

[0022] j = y m / l

[0023] k = z m / l

[0024] The " / " symbol is for integer division, meaning that after performing division on both sides of the symbol, only the integer part is taken.

[0025] S2.2, Triangle facet encoding, combines the encodings of the three vertices of a triangle facet to obtain the mID encoding:

[0026] mIDD = i1 * 2 56 +j1*2 49 +k1*2 42 +i2*2 35 +j2*2 28

[0027] +k2*2 21 +i3*2 14 +j3*2 7 +k3

[0028] or

[0029] mID = vID1 * 2 42 +vID2*2 21 +vID3

[0030] Where x, y, and z represent the order of the voxels containing the vertices in the three-dimensional direction; the subscripts 1, 2, and 3 represent the 1st, 2nd, and 3rd vertices in the triangular facet.

[0031] Furthermore, step S3 includes the following sub-steps:

[0032] S3.1, Voxel plane sorting, each voxel is surrounded by six planes, and the six planes are numbered in sequence;

[0033] S3.2, find the intersection of the voxel plane and the triangular facet. Substitute the coordinates of the vertices of the triangular facet into the plane equation to determine the positional relationship between the vertices and the plane: if all three vertices are on the same side of the plane, then the triangular facet does not intersect the plane; if the vertices are on opposite sides of the plane, then calculate the two intersection points between the triangular facet and the plane; determine the six planes in sequence according to their numbers.

[0034] S3.3, cut the triangular facets whose vertices are on both sides of the plane according to Delaunay's rule to obtain new triangular facets; re-encode all triangular facets to generate the corresponding mID.

[0035] Furthermore, step S4 includes the following sub-steps:

[0036] S4.1, triangular facet data storage, with each voxel's vID as a node, and a linked list containing triangular facet data placed in the node, to establish a hash bucket data structure;

[0037] S4.2, Establish a data buffer and store the data transmitted back from the edge into the data buffer.

[0038] Furthermore, step S5 includes the following sub-steps:

[0039] S5.1, Delete triangular facets within a specified voxel: Based on the tool position information transmitted back in real time from the edge simulation, determine the voxels that intersect with the tool, transmit the vIDs of the intersecting voxels to the web page, and store them in the data buffer; the web page reads these vIDs and deletes all triangular facets under the corresponding node in the hash bucket.

[0040] S5.2, Add newly generated triangular facets: Based on the edge simulation calculation, obtain the local triangular facets after tool cutting, transmit the local triangular facets to the buffer, encode the local triangular facets respectively and store them under the hash bucket node of the corresponding vID.

[0041] Furthermore, in step S6, the updated triangle facets are rendered and displayed using Three.js.

[0042] High-precision cutting simulation often requires substantial computing power. Existing geometric simulation methods typically use local computers for reading and writing model data, Boolean operations between the tool and workpiece during machining, and rendering in 3D software. Due to the large volume of model data, low data transmission efficiency, and limited computing power of web-based 3D rendering, smooth, efficient, and accurate geometric simulation is difficult to achieve in the cloud. Compared with existing technologies, this invention has at least the following advantages:

[0043] (1) This invention divides the model into voxel cubes of different sizes based on the look-ahead toolpath, and only updates the changes that occur locally. Therefore, compared with the traditional method, which updates the entire model, the amount of data transmitted is greatly reduced, and the GPU display rendering pressure is also greatly reduced. It is more efficient in both time and space, so real-time geometric simulation can be achieved on the web.

[0044] (2) The present invention designs a triangle encoding method based on the idea of ​​toolpath look-ahead. When adding, deleting, modifying and querying, it is not necessary to traverse all triangle faces. The triangle faces contained in the corresponding voxel block can be found and operated based on the encoding, which significantly improves efficiency.

[0045] (3) In order to achieve the gain effect (2), the present invention has designed an algorithm for dividing triangular facets into voxel meshes, which is applicable to triangular facet models of any shape and any number, and has reusability and portability.

[0046] (4) This invention constructs a hash bucket data structure for triangular facet models divided by voxel regions. Compared with general methods, which use one-dimensional containers for storage, this not only avoids wasting memory space, but also enables efficient and flexible CRUD operations. Attached Figure Description

[0047] To more clearly illustrate the technical solutions in the specific embodiments of the present invention, the drawings used in the description of the specific embodiments will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0048] Figure 1 This is a flowchart of the present invention;

[0049] Figure 2 A schematic diagram of voxel division for the workpiece model;

[0050] Figure 3 A schematic diagram of voxel vID encoding rules;

[0051] Figure 4 This is a schematic diagram of the vID data structure;

[0052] Figure 5 This is a schematic diagram of the mID data structure;

[0053] Figure 6 The order of intersection between the voxel boundary plane and the triangle;

[0054] Figure 7 A schematic diagram for finding the intersection of a single triangular facet with a plane;

[0055] Figure 8This is the process of dividing a triangular facet into voxel boundaries in a two-dimensional case; in the figure: (a) shows the positional relationship between the bold voxel and the triangular facet; (b) shows the order of intersection of the boundary planes; (c), (d), (e), and (f) show the specific division process;

[0056] Figure 9 A diagram illustrating Delaunay's Law; in the diagram: (a) shows the partitioning method that follows Delaunay's Law, and (b) shows the partitioning method that does not follow Delaunay's Law;

[0057] Figure 10 This is a schematic diagram of the hash bucket data structure; Detailed Implementation

[0058] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions in the embodiments of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the specific embodiments described are only for explaining this invention and are not intended to limit this invention. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.

[0059] This invention provides a method for dynamically updating a web-based triangular patch model based on voxel partitioning, such as... Figure 1 As shown, the main steps include:

[0060] Step 1: Voxel division and encoding. For example... Figure 2 As shown, the 3D model of the workpiece is divided into three levels of voxels (coarse-grained, fine-grained, and finest-grained) based on the look-ahead toolpath. Since only the area of ​​the 3D model of the workpiece that intersects with the tool needs to be updated during the cutting simulation, in order to improve efficiency, look-ahead toolpath and voxel division are performed: the 3D model of the workpiece is divided into voxels, resulting in several cubes of different sizes, i.e., voxels, and only the voxels that the tool may pass through are selected.

[0061] like Figure 3 As shown, each voxel is encoded using 21 bits of binary code based on the number of grid cells it represents in the x, y, and z directions, resulting in a unique voxelID, or simply vID. Figure 4 As shown:

[0062] vID = i * 2 14 +j*2 7 +k

[0063] Where i, j, k represent the order of the voxel in the x, y, z directions, i.e., which voxel it is.

[0064] Step 2: Triangular facet encoding, which includes the following steps:

[0065] Step 2.1: Vertex encoding of triangle patches. For example... Figure 3 As shown, let the vertex coordinates be x. m y m z m For a voxel with side length l, the code of the vertex is the code of the voxel it belongs to, calculated by the following formula:

[0066] vID = i * 2 14 +j*2 7 +k

[0067] in

[0068] i = x m / l

[0069] j = y m / l

[0070] k = z m / l

[0071] The " / " symbol is for integer division, meaning that after performing a division operation on both sides of the symbol, only the integer part is taken.

[0072] A 7-bit binary number can represent up to 128 voxels. The minimum side length of a voxel is 5mm. This means that the encoding method can represent a cube workspace with a side length of up to 640mm, which can meet most CNC machining needs.

[0073] Step 2.2: Triangle Patch Encoding. The codes of the three vertices of a triangle patch are combined to obtain the meshID, or mID for short, such as... Figure 5 Represented as a 64-bit long integer in binary:

[0074] mID = i1 * 2 56 +j1*2 49 +k1*2 42 +i2*2 35 +j2*2 28

[0075] +k2*2 21 +i3*2 14 +j3*2 7 +k3

[0076] or

[0077] mID = vID1 * 2 42 +vID2*2 21 +vID3

[0078] Where i1, j1, k1 represent the order of the voxels containing the first vertex in the three-dimensional direction, i2, j2, k2 represent the order of the voxels containing the second vertex in the three-dimensional direction, and i3, j3, k3 represent the order of the voxels containing the third vertex in the three-dimensional direction.

[0079] If the codes of the three vertices of a triangle are consistent, it means that the triangle is completely contained within a single voxel and does not need to be segmented; if they are inconsistent, it means that the triangle is contained within different voxels and needs to be segmented.

[0080] Step 3: Triangular facet segmentation. The purpose of this step is to segment cross-voxel triangular facets along the voxel boundaries. Each newly generated small triangular facet has its vertices completely contained within the same voxel. The specific method is as follows:

[0081] Step 3.1: Voxel Plane Sort. Each voxel consists of six faces. Number the six faces sequentially, as follows: Figure 6 When cutting triangular faces, calculate the positional relationship between the voxel plane and the triangular facet in this order;

[0082] Step 3.2: Find the intersection of the voxel plane and the triangular facet. For example... Figure 7 Substitute the coordinates of the vertices of the triangular facet into the plane equation to determine the positional relationship between vertices A, B, and C and the plane: if all three vertices are on the same side of the plane, then the triangular facet does not intersect the plane, and the next plane is calculated; if the vertices are on opposite sides of the plane, then the two intersection points D and E between the triangular facet and the plane are calculated.

[0083] Step 3.3: Generate the cut triangular facets. For example... Figure 8 As shown, for ease of understanding, a two-dimensional example is used. Assume a model contains only one triangular facet, which is then divided into 2×2 voxels. The three-dimensional process can be analogous. Figure 8 (a) shows the positional relationship between the triangular facets and the coarse voxel mesh, indicating that the mesh will be divided according to these voxels; Figure 8 (b)-8(f) shows the process of cutting the triangular face under this voxel division. Figure 8 (b) only shows the order of intersection between the top-left voxel boundary and the triangular facet. To complete the segmentation, all boundaries of each voxel square in the top-left, top-right, bottom-right, and bottom-left sections must intersect and cut with the triangular facets. The cutting order of each voxel boundary is clockwise. Figure 8 (b) Consistent, if in three dimensions, follow the order in step 3.1). A triangular facet is divided into a triangle and a quadrilateral by a single voxel boundary. Given the coordinates of each vertex, connect them according to Delaunay's rule to form a new triangular facet, such as... Figure 8 (c) Then perform the next cut, such as Figure 8(d) After sequentially intersecting all voxel boundaries with all triangular faces, coarse voxel segmentation is completed, and the result is as follows: Figure 8 (e). Figure 8 (f) shows the result of the coarse mesh division and the positional relationship for the next fine mesh division (assuming that the lower left voxel needs to be subdivided during toolpath look-ahead). The fine mesh division is performed in the same steps as the coarse mesh division. All triangular faces are re-encoded to generate the corresponding mIDs.

[0084] Delaunay's rule is a characteristic of Delaunay's triangulation method. For example, to connect four points to form two triangular faces, there are two connection methods, such as... Figure 9 Method (b) violates Delaunay's rule, resulting in triangles with sharp interior angles after segmentation. Such triangles are called silver triangles, which perform poorly in linear interpolation and should therefore be avoided. Delaunay's rule maximizes the sum of the smallest angles of all triangles.

[0085] Step 4: Prepare data. Based on the toolpath look-ahead results, screen the voxels that may be cut, thereby preparing the triangular facets that need to be modified in advance to improve efficiency. This includes the following steps:

[0086] Step 4.1: Data Storage of Triangular Facets. Voxels have three sizes, therefore three levels of vID. Using each voxel's vID as a node, a linked list containing the triangular facet data is placed within each node, establishing a hash bucket data structure, as follows: Figure 10 This way, all the triangular faces contained in a voxel block can be retrieved using only the vID of a given voxel;

[0087] Step 4.2: Establish a data buffer. Since the edge-cloud communication frequency differs from the web-based model refresh frequency, information transmitted from the edge needs to be stored in a buffer before any operations are performed.

[0088] Step 5: Update the triangular facet model. This step specifically includes:

[0089] Step 5.1: Delete triangular faces within a specified voxel. Based on the tool position information transmitted back in real-time from the edge simulation, determine which finest-grained voxels the tool is intersecting with. The vIDs of the intersecting voxels are transmitted to the web client and stored in a buffer. The web client reads these vIDs and deletes all triangular faces under the corresponding node from the hash bucket.

[0090] Step 5.2: Add newly generated triangular faces. Based on edge simulation calculations, the local triangular face model after tool cutting can be obtained, and these triangular faces are transferred to the buffer. When processing the buffer, these newly added triangular faces are encoded and attached to the hash bucket node of the corresponding vID.

[0091] Step 6: Visual rendering.

[0092] This step is the final step in a single loop of the web-based cutting simulation. It's used to render the triangular facet data stored in the hash bucket onto the screen using Three.js. Three.js offers various web rendering methods; this example recommends using BufferGeometry to construct the basic data structure for storing the triangular facets and then rendering it.

[0093] BufferGeometry is an efficient representation of face, line, or point geometry. It includes vertex positions, face indices, normals, color values, UV coordinates, and custom cached attribute values. Using BufferGeometry can effectively reduce the overhead required to transfer this data to the GPU. In this example, triangles are arranged in groups of three vertices, consistent with the vertex array arrangement rules of BufferGeometry.

[0094] Finally, it should be noted that the foregoing embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit them. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for dynamic updating of a web-based triangular facet model based on voxel division, characterized in that, The method comprises the following steps: S1, voxel division and coding: the blank three-dimensional model is divided into voxels, and each voxel is coded; S2, triangular facet coding: reading in the blank triangular facet model, and coding the triangular facets; S3, triangular facet segmentation: determining the positional relationship between voxels and triangular facets through voxel coding and triangular facet coding, if the triangular facet is completely contained in a voxel, it does not need to be segmented; otherwise, the triangular facet crossing the voxel is segmented along the voxel boundary to obtain the segmented triangular facet, and the segmented triangular facet is contained in a voxel; S4, data preparation: screening out the voxels to be cut according to the tool path, taking the coding of each voxel to be cut as a node, placing a linked list containing triangular facet coding in the node, and establishing a hash bucket-shaped data structure; S5, dynamic updating of triangular facets: according to the tool position information returned by the edge terminal simulation in real time, the voxels intersecting with the tool are screened, the coding of the intersecting voxels is read by the web terminal, and all triangular facets under the corresponding node in the hash bucket are deleted; according to the new triangular facets generated after the tool is cut by the edge terminal simulation, the new triangular facets are coded and stored under the hash bucket node; S6, visual rendering: rendering and displaying the updated triangular facets to realize the geometric simulation of the web terminal.

2. The method of claim 1, wherein, The step S1 is specifically: The blank three-dimensional model is divided into voxels, and each voxel is coded according to the number of grids arranged in x, y and z directions to obtain a unique vID code: vID = x*2 14 +y*2 7 +z Wherein, x, y, z represent the number of grids arranged in three-dimensional directions.

3. The method of claim 2, wherein, The step S2 comprises the following sub-steps: S2.1, triangle vertex encoding, the triangle vertex coordinates are x m , y m , z m , and the voxel edge length is l. The encoding of the vertex, that is, the encoding of the voxel in which the vertex is located, is calculated by the following formula: vID = i * 2 14 + j * 2 7 + k Wherein, i=x m / l j=y m / 1 k = z m / " / " is the integer division symbol, that is, only the integer part is taken after the division operation is performed on the left and right sides of the symbol; S2.2, triangular facet coding: integrating the coding of the three vertices of the triangular facet to obtain an mID code: mID = i1*2 56 + j1*2 49 + k1*2 42 + i2*2 35 + j2*2 28 + k2*2 21 + i3*2 14 + j3*2 7 + k3 Or mID = vID1 * 2 42 + vID2 * 2 21 + vID3 Wherein, x, y, z represent the order of the vertex in the three-dimensional direction; the subscripts 1, 2 and 3 represent the first, second and third vertices in the triangular facet.

4. The method of claim 3, wherein, The step S3 comprises the following sub-steps: S3.1, voxel plane ordering: each voxel is surrounded by six planes, and the six planes are sequentially numbered; S3.2, intersection of voxel plane and triangular facet: the vertex coordinates of the triangular facet are substituted into the plane equation to determine the positional relationship between the vertex and the plane: if the three vertices are on the same side of the plane, the triangular facet does not intersect with the plane; if the vertex is on both sides of the plane, two intersection points of the triangular facet and the plane are calculated; the six planes are sequentially determined according to the sequential numbering; S3.3, the triangular facet with the vertex on both sides of the plane is cut according to the Delaunay rule to obtain a new triangular facet; all the triangular facets are recoded to generate the corresponding mID.

5. The method of claim 4, wherein, The step S4 comprises the following sub-steps: S4.1, triangular facet data storage: taking the vID of each voxel as a node, placing a linked list containing triangular facet data in the node, and establishing a hash bucket-shaped data structure; S4.2, establishing a data buffer area, and storing the data returned by the edge terminal into the data buffer area.

6. The method of claim 5, wherein, The step S5 comprises the following sub-steps: S5.1, delete the specified triangle in the voxel: according to the edge end simulation real-time returned tool position information, judge the intersected voxel with the tool, transmit the vID of the intersected voxel to the webpage end and store it in the data buffer; the webpage end reads these vIDs and deletes all the triangular facets under the corresponding nodes in the hash bucket; S5.2, add new generated triangular facets: according to the edge end simulation operation, get the local triangular facets after tool cutting, transmit the local triangular facets to the buffer, encode and store the local triangular facets to the hash bucket node corresponding to the vID respectively.

7. The method of claim 6, wherein, The step S6 adopts Threejs to render and display the updated triangular facets.

Images