Method and system for realizing 3D model rendering on application software

Abstract

The invention discloses a method and system for achieving 3D model rendering on application software, and the method comprises the following steps: loading and analyzing a 3D model file, and obtaining geometric information of a 3D model, including but not limited to triangular patch normal vector data, triangular patch normal vertex data, the number of triangular patches, and maximum and minimum X / Y / Z axis coordinates; a GLSurfaceView instance is created, the surface rendered by the OpenGL is managed, meanwhile, a Renderer object is accepted, and the object executes an actual rendering task; and S3, rendering the 3D model in the environment created in the S2 by using the data obtained in the S1. By optimizing the loading and analyzing process of the 3D model file and combining the efficient OpenGL rendering technology, smooth and high-quality 3D model rendering can be achieved on the mobile device with low performance, efficient and high-quality 3D model rendering can be achieved on the mobile device with low performance, and the problems of performance bottleneck and high memory occupation in the prior art are solved.

Description

Technical Field

[0001] The present invention belongs to the field of computer technology, and in particular relates to a method and system for implementing 3D model rendering on application software. Background Art

[0002] With the development of computer technology and graphics, 3D model rendering technology has become one of the key technologies in many fields such as film and television production, game development, and architectural design. 3D model rendering refers to the process of converting objects in a three-dimensional scene into two-dimensional images through computer technology. This process involves complex calculations in many aspects such as lighting, materials, and shadows. However, existing 3D model rendering technology faces many challenges in practical applications, especially in achieving efficient and high-quality 3D model rendering on mobile devices. There are significant technical barriers.

[0003] For example, Unity is a widely used 3D model rendering engine that provides powerful 3D model rendering capabilities. However, Unity has obvious performance bottlenecks when processing complex 3D models, especially on mobile devices with lower performance. It is easy to experience freezes or frame rate drops when rendering complex 3D models. In addition, Unity takes up a lot of memory when loading 3D models, especially when the models contain complex textures and polygons, which may cause application crashes or insufficient memory. These problems severely limit the widespread application of 3D model rendering technology on mobile devices. Summary of the invention

[0004] The purpose of the present invention is to provide a method and system for implementing 3D model rendering on application software, aiming to solve the performance bottleneck and high memory usage problems of existing 3D model rendering technology on mobile devices, so as to improve rendering efficiency and reduce memory usage.

[0005] To achieve the above object, the present invention provides, in one aspect, a method for implementing 3D model rendering on application software, comprising the following steps:

[0006] S1: Load and parse the 3D model file to obtain geometric information of the 3D model, including but not limited to triangle normal vector data, triangle normal vertex data, number of triangles, and maximum and minimum X / Y / Z axis coordinates;

[0007] S2: Create a GLSurfaceView instance to manage the surface rendered by OpenGL and accept a Renderer object, which performs the actual rendering task.

[0008] S3: Use the data obtained in S1 to render the 3D model in the environment created in S2.

[0009] Preferably, in S1, it includes: creating a structure for encapsulating 3D model file data, wherein the structure is used to store all relevant information after the 3D model file is parsed; looping to read the 3D model file and converting it into a string data type; extracting the triangle facet normal vector data and the number of triangle facets corresponding to the facet normal field from the converted string data, and encapsulating them into the structure; extracting the triangle facet normal vertex data and the maximum and minimum X / Y / Z axis coordinates corresponding to the vertex field from the converted string data, and encapsulating them into the structure.

[0010] Preferably, in S2, it includes: managing EGL display to ensure that OpenGL rendering can be correctly displayed on the surface; receiving and registering a Renderer object, which is responsible for executing specific rendering logic; performing rendering on a thread independent of the UI thread to improve rendering performance; supporting the selection of on-demand rendering and continuous rendering modes.

[0011] Preferably, the method further includes S4: realizing the interaction between the user and the 3D model by implementing the onTouchEvent method of GLSurfaceView, allowing the user to control the rotation and translation of the 3D model through touch screen gestures.

[0012] Preferably, in S4, it includes: implementing the onTouchEvent method of GLSurfaceView to monitor the user's touch actions in real time; calculating the rotation angle of the 3D model around the X-axis, Y-axis and / or Z-axis according to the user's touch actions; updating the posture of the 3D model according to the calculation results, and re-rendering the 3D model.

[0013] On the other hand, the present invention provides a method system for implementing 3D model rendering on application software, comprising:

[0014] The data parsing module is used to load and parse the 3D model file to obtain the geometric information of the 3D model;

[0015] The rendering management module is used to create GLSurfaceView instances, manage OpenGL rendering surfaces, and receive Renderer objects;

[0016] The rendering execution module uses the data obtained by the data parsing module to perform rendering of the 3D model in the environment created by the rendering management module.

[0017] Preferably, the data parsing module includes: a structure creation unit, used to create a structure that encapsulates 3D model file data; a file reading unit, used to cyclically read the 3D model file and convert it into a string data type; a normal vector data extraction unit, used to extract triangle face normal vector data and the number of triangle faces from the string data; a vertex data extraction unit, used to extract triangle face normal vertex data and maximum and minimum X / Y / Z axis coordinates from the string data.

[0018] Preferably, the rendering management module includes: a display management unit for managing EGL display to ensure that OpenGL rendering can be displayed correctly; a Renderer object receiving unit for receiving and registering a Renderer object that executes rendering logic; a thread management unit for performing rendering on a thread independent of the UI thread to improve rendering performance; and a rendering mode selection unit for supporting selection of on-demand rendering and continuous rendering modes.

[0019] Preferably, an interactive control module is also included to implement interaction between the user and the 3D model, including but not limited to rotation and translation control.

[0020] Preferably, the interactive control module includes: a touch event monitoring unit, used to monitor the user's touch actions in real time; an action analysis unit, used to calculate the rotation angle of the 3D model around the X-axis, Y-axis and / or Z-axis according to the user's touch actions; and a posture updating unit, used to update the posture of the 3D model according to the calculation results and trigger re-rendering of the 3D model.

[0021] Technical effects and advantages of the present invention: Compared with the prior art, the present invention provides a method and system for implementing 3D model rendering on application software, which has the following advantages:

[0022] The present invention uses an efficient data parsing algorithm to quickly load 3D model files and extract necessary geometric information, such as triangle normal vector data, normal vertex data, number of triangles, and maximum and minimum X / Y / Z axis coordinates. This step reduces the time of data processing and improves loading efficiency. GLSurfaceView is used to manage the surface rendered by OpenGL, and accepts the Renderer object to perform the actual rendering task. GLSurfaceView can effectively manage the EGL display to ensure that the OpenGL rendering can be correctly displayed on the mobile device. At the same time, it supports on-demand rendering and continuous rendering, and can flexibly select the rendering mode according to actual needs to further improve the rendering performance. By optimizing the loading and parsing process of the 3D model file and combining the efficient OpenGL rendering technology, it can achieve smooth and high-quality 3D model rendering on mobile devices with lower performance, and can achieve efficient and high-quality 3D model rendering on mobile devices with lower performance, solving the performance bottleneck and high memory usage problems existing in the prior art. BRIEF DESCRIPTION OF THE DRAWINGS

[0023] Figure 1 A flowchart of a method for implementing 3D model rendering on application software according to the present invention;

[0024] Figure 2 The present invention is a block diagram of a 3D model rendering system implemented on application software. DETAILED DESCRIPTION

[0025] The following will be combined with the accompanying drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, rather than all the embodiments. The specific embodiments described herein are only used to explain the present invention and are not used to limit the present invention. Based on the embodiments in the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention.

[0026] The present invention provides a method for implementing 3D model rendering on application software, aiming to solve the performance bottleneck and high memory usage problems of existing 3D model rendering technology on mobile devices, and provides a method for implementing 3D model rendering on application software to improve rendering efficiency and reduce memory usage. The details are as follows:

[0027] like Figure 1 As shown, the 3D model rendering method implemented on the application software in this embodiment includes the following steps:

[0028] S1: Load and parse the 3D model file to obtain geometric information of the 3D model, including but not limited to triangle normal vector data, triangle normal vertex data, number of triangles, and maximum and minimum X / Y / Z axis coordinates;

[0029] A 3D model file is a file format used to represent a triangular mesh in a computer graphics application system. It contains geometric information of a triangular face. The information unit of a triangular face in the file is a triangular face with a vector direction. A 3D model is composed of a series of such triangular faces. The above S1 further includes:

[0030] Create a structure for encapsulating 3D model file data, the structure is used to store all relevant information after the 3D model file is parsed; read the 3D model file in a loop and convert it into a string data type;

[0031] Extract the triangle normal vector data and the number of triangles corresponding to the facet normal field from the converted string data, and encapsulate them into the structure;

[0032] Extract the triangle patch method vertex data and the maximum and minimum X / Y / Z axis coordinates corresponding to the vertex field from the converted string data, and encapsulate them into the structure.

[0033] By creating a structure to encapsulate 3D model file data and using efficient string processing and data extraction methods, the loading and parsing speed of 3D model files is significantly improved. By gradually reading and parsing 3D model files, it avoids loading the entire file into memory at one time, reducing memory usage. Using OpenGL technology, efficient and high-quality 3D model rendering is achieved on mobile devices, supporting user interaction with 3D models, such as rotation and translation, which improves the user experience.

[0034] S2: Create a GLSurfaceView instance to manage the surface rendered by OpenGL and accept a Renderer object, which performs the actual rendering task.

[0035] Specifically, GLSurfaceView is a SurfaceView implementation that uses a dedicated Surface to display OpenGL rendering. GLSurfaceView provides the following functions and solutions: Manages the surface, which is a special piece of memory that can be synthesized into the Android view system. Manages the EGL display, enabling OpenGL to render to the surface. Accepts a Renderer object, which performs the actual rendering. Renders on a dedicated thread to decouple rendering performance from the UI thread. Supports on-demand and continuous rendering. Wraps, tracks, and error-checks the renderer's OpenGL calls. Implements touch monitoring methods, and finger sliding on the interface can rotate the 3D model around the X / Y / Z axis.

[0036] The above S2 further includes: managing EGL display to ensure that OpenGL rendering can be correctly displayed on the surface; receiving and registering a Renderer object, which is responsible for executing specific rendering logic; performing rendering on a thread independent of the UI thread to improve rendering performance; supporting the selection of on-demand rendering and continuous rendering modes.

[0037] By implementing the onTouchEvent method of GLSurfaceView, the user's touch on the phone screen is monitored in real time, and the user's gestures of pressing, moving, and leaving the screen are recognized. After the gesture is recognized, the coordinates corresponding to the gesture are obtained, and the 3D model is updated and drawn according to the coordinates, thereby realizing the interaction between the user and the 3D model. The interface layout is the GLSurfaceView view, which is used to render the view layer of the 3D model graphics.

[0038] S3: Use the data obtained in S1 to render the 3D model in the environment created in S2.

[0039] In the first two steps, we have successfully loaded and parsed the 3D model file, obtained the geometric information of the 3D model, and created a GLSurfaceView instance to manage the surface rendered by OpenGL. Next, we will use this data to render the 3D model in the GLSurfaceView environment.

[0040] Implementation steps:

[0041] Initialize the OpenGL environment: Initialize the OpenGL environment in the Renderer class of GLSurfaceView and set the necessary OpenGL parameters.

[0042] Define vertex shader and fragment shader: Write vertex shader and fragment shader code to process vertex and color information of 3D models.

[0043] Compile and link shader programs: Compile and link vertex shaders and fragment shaders into an executable shader program.

[0044] Load vertex data and normal vector data to the GPU: Use OpenGL's VBO (Vertex BufferObject) to load vertex data and normal vector data into the GPU.

[0045] Set rendering state: Set the rendering state of OpenGL, such as enabling depth testing, color mixing, etc.

[0046] Draw 3D model: Call OpenGL's drawing function in each frame to draw the 3D model on the screen.

[0047] By using VBO (Vertex Buffer Object), vertex data and normal vector data are directly loaded into the GPU, reducing the data transmission overhead between the CPU and GPU and improving rendering performance.

[0048] By writing efficient vertex shaders and fragment shaders, the color and lighting effects of the 3D model are ensured, and the rendering quality is improved. The onDrawFrame method is called in each frame to dynamically draw the 3D model, supporting user interaction with the 3D model, such as rotation and translation, to enhance the user experience.

[0049] By reading and parsing 3D model files step by step, it avoids loading the entire file into memory at once, reduces memory usage, and allows smooth operation on mobile devices with lower performance. Using OpenGL technology, efficient and high-quality 3D model rendering is achieved on mobile devices, supporting a variety of complex 3D models and meeting the needs of different application scenarios.

[0050] In summary, the present invention optimizes the loading and parsing process of 3D model files and combines it with efficient OpenGL rendering technology to achieve smooth, high-quality 3D model rendering on low-performance mobile devices, thereby solving the performance bottleneck and high memory usage problems existing in the prior art.

[0051] In addition, the Renderer is a general renderer interface that is responsible for making OpenGL calls to render frames. It is the module in the Android system that is responsible for converting drawing instructions into actual images, converting drawing operations into final pixel data, and displaying them on the screen. The Renderer selects the appropriate rendering method based on the performance and characteristics of the hardware device, such as using the GPU for hardware accelerated rendering. The Renderer also handles image blending, masking, filtering, and animation processing.

[0052] Implementation Notes:

[0053] Create a custom StlRenderer to implement the Renderer interface;

[0054] Implement the onSurfaceCreated initialization method and onDrawFrame drawing method of the Renderer interface, set the OpenGL parameter settings, environment configuration, etc. in the onSurfaceCreated initialization method, and implement the OpenGL drawing operation in the onDrawFrame drawing method;

[0055] Set the environment configuration implementation in the onSurfaceCreated initialization method:

[0056] / / Clear the color cache with the specified color

[0057] / / Start color mixing

[0058] / / Set the source factor and target factor

[0059] / / Start updating the depth buffer

[0060] / / Specify the depth buffer comparison value

[0061] / / Normals are normalized after conversion

[0062] / / Set the transition mode of other points' colors between two points

[0063] / / Start operating the projection matrix

[0064] / / Turn on the light source

[0065] / / Set the global ambient light

[0066] / / Use GL_LIGHTO light source

[0067] / / Set the ambient color and scattering color of the material

[0068] / / Set the light source position.

[0069] In another embodiment, the method further includes: drawing the model using OpenGL, which is a cross-platform graphics API that specifies a standard software interface. Drawing the model requires setting OpenGL related parameters, and then drawing according to the encapsulated 3D model data structure.

[0070] OpenGL drawing process implementation description:

[0071] / / Set the rotation and offset

[0072] / / Set the zoom

[0073] / / Enable vertex array functionality

[0074] / / Start operating the model view

[0075] / / Allow writing to the depth buffer

[0076] / / Use color material

[0077] / / Set the material environment color

[0078] / / Set the material scattering color

[0079] / / Save the current state

[0080] / / Use VBO cache

[0081] / / Load 3D model structure data

[0082] / / Draw 3D model

[0083] / / Restore the previously saved state

[0084] / / Disable the color material.

[0085] In another embodiment, it also includes: VBO cache, where VBO (Vertex Buffer Object) refers to a vertex buffer object.

[0086] The vertex array data used for drawing is first saved in the CPU memory. When calling gIDrawArrays or gIDrawElements for drawing, the vertex array data needs to be copied from the CPU memory to the GPU memory. It is not necessary to copy the memory every time you draw. VBO can cache this data in the GPU memory, which greatly reduces the overhead caused by memory copying.

[0087] The role of VBO is to open up a block of memory in the GPU video memory in advance to cache vertex data, thereby avoiding memory copying between the CPU and GPU each time drawing, improving rendering performance, and reducing memory bandwidth and power consumption.

[0088] VBO cache implementation instructions:

[0089] 1) Initialize and generate VBO;

[0090] 2) Bind VBO through OpenGL method;

[0091] 3) Send vertex data to VBO and bind vertex data;

[0092] 4) Use VBO rendering to reduce memory overhead;

[0093] 5) Delete VBO and release VBO resources.

[0094] The present invention loads and parses 3D model files, obtains triangular face information, encapsulates 3D model data, uses OpenGL to draw according to the encapsulated 3D model data, uses VBO for caching, and reduces memory overhead. The Renderer renders on the GLSurfaceView interface, thereby realizing a technical solution for 3D model rendering on application software.

[0095] In another embodiment, it also includes S4: realizing the interaction between the user and the 3D model by implementing the onTouchEvent method of GLSurfaceView, allowing the user to control the rotation and translation of the 3D model through touch screen gestures.

[0096] It further includes: implementing the onTouchEvent method of GLSurfaceView to monitor the user's touch actions in real time; calculating the rotation angle of the 3D model around the X-axis, Y-axis and / or Z-axis according to the user's touch actions; updating the posture of the 3D model according to the calculation results, and re-rendering the 3D model.

[0097] On the other hand, the present invention provides a 3D model rendering system implemented on application software, such as Figure 2 As shown, including:

[0098] The data parsing module is used to load and parse the 3D model file to obtain the geometric information of the 3D model;

[0099] Furthermore, the data parsing module includes: a structure creation unit, which is used to create a structure that encapsulates 3D model file data; a file reading unit, which is used to loop read the 3D model file and convert it into a string data type; a normal vector data extraction unit, which is used to extract the triangle face normal vector data and the number of triangle faces from the string data; and a vertex data extraction unit, which is used to extract the triangle face normal vertex data and the maximum and minimum X / Y / Z axis coordinates from the string data.

[0100] The rendering management module is used to create a GLSurfaceView instance, manage the surface rendered by OpenGL, and receive the Renderer object; the rendering execution module uses the data obtained by the data parsing module to perform the rendering of the 3D model in the environment created by the rendering management module.

[0101] Furthermore, the rendering management module includes: a display management unit, which is used to manage the EGL display and ensure that the OpenGL rendering can be displayed correctly; a Renderer object receiving unit, which is used to receive and register the Renderer object that executes the rendering logic; a thread management unit, which is used to perform rendering on a thread independent of the UI thread to improve rendering performance; a rendering mode selection unit, which is used to support the selection of on-demand rendering and continuous rendering modes.

[0102] The interactive control module is used to realize the interaction between the user and the 3D model, including but not limited to rotation and translation control. Further, the interactive control module includes: a touch event monitoring unit, which is used to monitor the user's touch action in real time; an action parsing unit, which is used to calculate the rotation angle of the 3D model around the X axis, Y axis and / or Z axis according to the user's touch action; a posture updating unit, which is used to update the posture of the 3D model according to the calculation result and trigger the re-rendering of the 3D model.

[0103] In addition, the above-mentioned data analysis module, rendering management module and rendering execution module are also used to implement the other steps of the above-mentioned 3D model rendering method on the application software when executed, which are not described one by one here.

[0104] In summary, the present invention uses an efficient data parsing algorithm to quickly load 3D model files and extract necessary geometric information, such as triangle normal vector data, normal vertex data, number of triangles, and maximum and minimum X / Y / Z axis coordinates. This step reduces the time of data processing and improves loading efficiency. GLSurfaceView is used to manage the surface rendered by OpenGL and accepts the Renderer object to perform the actual rendering task. GLSurfaceView can effectively manage EGL display and ensure that OpenGL rendering can be correctly displayed on mobile devices.

[0105] At the same time, it supports on-demand rendering and continuous rendering, and can flexibly select rendering modes according to actual needs to further improve rendering performance. By optimizing the loading and parsing process of 3D model files and combining efficient OpenGL rendering technology, it can achieve smooth and high-quality 3D model rendering on low-performance mobile devices. It can achieve efficient and high-quality 3D model rendering on low-performance mobile devices, solving the performance bottleneck and high memory usage problems in existing technologies.

[0106] The meanings of the terms and abbreviations in this embodiment are as follows:

[0107] 3D: Three Dimensions;

[0108] MeshRenderer: A component used for rendering on the Unity platform;

[0109] Camera: Camera;

[0110] GLSurfaceView SurfaceView: View class used to render OpenGL graphics on the Android platform;

[0111] Renderer: A core class for processing and drawing graphics on the Android platform;

[0112] OpenGL: a cross-platform graphics API (Open Graphics Library);

[0113] EGL: an interface layer (Embedded Graphics Library);

[0114] VBO: Vertex Buffer Object;

[0115] CPU: Central Processing Unit;

[0116] GPU: Graphics Processing Unit;

[0117] Canvas: A tool for drawing graphics on the Android platform.

[0118] Finally, it should be noted that the above is only a preferred embodiment of the present invention and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the aforementioned embodiments, it is still possible for those skilled in the art to modify the technical solutions described in the aforementioned embodiments or to make equivalent substitutions for some of the technical features therein. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention should be included in the protection scope of the present invention.

Claims

1. A method for implementing 3D model rendering on application software, characterized in that: The following steps are involved: S1: Load and parse the 3D model file to obtain geometric information of the 3D model, including but not limited to triangle normal vector data, triangle normal vertex data, number of triangles, and maximum and minimum X / Y / Z axis coordinates; S2: Create a GLSurfaceView instance to manage the surface rendered by OpenGL and accept a Renderer object, which performs the actual rendering task. S3: Use the data obtained in S1 to render the 3D model in the environment created in S2.

2. A method for implementing 3D model rendering on application software according to claim 1, characterized in that: In S1, it includes: Create a structure for encapsulating 3D model file data, wherein the structure is used to store all relevant information after the 3D model file is parsed; Loop through the 3D model file and convert it into a string data type; Extract the triangle normal vector data and the number of triangles corresponding to the facet normal field from the converted string data, and encapsulate them into the structure; Extract the triangle patch method vertex data and the maximum and minimum X / Y / Z axis coordinates corresponding to the vertex field from the converted string data, and encapsulate them into the structure.

3. A method for implementing 3D model rendering on application software according to claim 2, characterized in that: In S2, it includes: Manage EGL display to ensure that OpenGL rendering can be correctly displayed on the surface; Receive and register the Renderer object, which is responsible for executing specific rendering logic; Perform rendering on a thread separate from the UI thread to improve rendering performance; Supports selection of on-demand rendering and continuous rendering modes.

4. A method for implementing 3D model rendering on application software according to claim 3, characterized in that: Also included is S4: Implementing the onTouchEvent method of GLSurfaceView to enable user interaction with the 3D model, allowing the user to control the rotation and translation of the 3D model through touch screen gestures.

5. A method for implementing 3D model rendering on application software according to claim 4, characterized in that: In S4, it includes: Implement the onTouchEvent method of GLSurfaceView to monitor the user's touch actions in real time; Calculate the rotation angle of the 3D model around the X-axis, Y-axis and / or Z-axis according to the user's touch action; The pose of the 3D model is updated according to the calculation results, and the 3D model is re-rendered.

6. A system for implementing a 3D model rendering method on application software according to any one of claims 1 to 5, characterized in that: include: The data parsing module is used to load and parse the 3D model file to obtain the geometric information of the 3D model; The rendering management module is used to create GLSurfaceView instances, manage OpenGL rendering surfaces, and receive Renderer objects; The rendering execution module uses the data obtained by the data parsing module to perform rendering of the 3D model in the environment created by the rendering management module.

7. A 3D model rendering system implemented on application software according to claim 6, characterized in that: The data parsing module comprises: A structure creation unit, used to create a structure that encapsulates 3D model file data; The file reading unit is used to cyclically read the 3D model file and convert it into a string data type; A normal vector data extraction unit, used for extracting triangle face normal vector data and triangle face quantity from the character string data; The vertex data extraction unit is used to extract the triangle patch method vertex data and the maximum and minimum X / Y / Z axis coordinates from the character string data.

8. A system for implementing 3D model rendering on application software according to claim 7, characterized in that: The rendering management module includes: Display management unit, used to manage EGL display and ensure that OpenGL rendering can be displayed correctly; A Renderer object receiving unit, used to receive and register a Renderer object that executes rendering logic; Thread management unit, used to perform rendering on a thread independent of the UI thread, improving rendering performance; The rendering mode selection unit is used to support the selection of on-demand rendering and continuous rendering modes.

9. A 3D model rendering system implemented on application software according to claim 8, characterized in that: It also includes an interactive control module for realizing the interaction between the user and the 3D model, including but not limited to rotation and translation control.

10. A 3D model rendering system implemented on application software according to claim 9, characterized in that: The interactive control module comprises: A touch event monitoring unit, used to monitor the user's touch actions in real time; An action analysis unit, used to calculate the rotation angle of the 3D model around the X-axis, Y-axis and / or Z-axis according to the user's touch action; The posture updating unit is used to update the posture of the 3D model according to the calculation result and trigger the re-rendering of the 3D model.

Images