Video image processing method, electric equipment, computer storage medium and computer program product
By using an adaptive anti-aliasing algorithm (APAA), adjusting the Gaussian kernel radius and standard deviation, and combining it with CPU-based edge detection, the problem of balancing image quality and performance is solved, achieving efficient image quality and performance optimization.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-09-30
- Publication Date
- 2026-04-07
AI Technical Summary
Existing anti-aliasing algorithms struggle to balance image quality and performance, resulting in high performance overhead or inaccurate edge detection.
An adaptive anti-aliasing algorithm (APAA) is adopted. By adjusting the Gaussian kernel radius and standard deviation to calculate the weight array, the video image is blurred. Combined with CPU edge detection, the image quality and performance are optimized.
While maintaining high image quality, it significantly reduces performance consumption, improves the accuracy of edge detection, and reduces image jaggedness and jitter.
Smart Images
Figure CN121814982A_ABST
Abstract
Description
TECHNICAL FIELD
[0001] The present application belongs to the technical field of computers, and particularly relates to a video image processing method, an electrical device, a computer storage medium, and a computer program product. BACKGROUND
[0002] With the increasing demand of users for image quality, the anti-aliasing technology as a pain point has also developed rapidly. However, while pursuing image quality, people also have high requirements for the rendering performance of videos and 3D images. Image quality and performance have always been mutually exclusive, and how to balance the two has become a difficulty.
[0003] The existing mainstream anti-aliasing algorithms have advantages and disadvantages, and do not consider the trade-off between performance and image quality. Some consume a lot of performance, some rely on hardware, and some edge detection is not accurate enough. SUMMARY
[0004] Therefore, the embodiments of the present application provide a video image processing method, an electrical device, a computer storage medium, and a computer program product to solve the problems in the prior art.
[0005] The first aspect of the present application provides a video image processing method, comprising: obtaining first texture data of a first frame of a video image; performing blur processing on a second frame to obtain second texture data; and mixing the first texture data and the second texture data and outputting the video image.
[0006] In some embodiments, performing blur processing on the second frame to obtain the second texture data comprises: adjusting a Gaussian kernel radius of a Gaussian kernel according to a frame rate of the video image, calculating a weight array according to the Gaussian kernel radius and a standard deviation; and performing blur processing on the second frame using the weight array to obtain the second texture data.
[0007] In some embodiments, adjusting the Gaussian kernel radius according to the frame rate of the video image comprises: increasing the Gaussian kernel radius when the frame rate of the video image is higher than a threshold value; and / or decreasing the Gaussian kernel radius when the frame rate of the video image is lower than the threshold value.
[0008] In some embodiments, calculating the weight array of the Gaussian kernel comprises: creating a coordinate system with a pixel point to be calculated as the origin, and the positive and negative coordinate ranges being the Gaussian kernel radius; calculating the square of the distance of each pixel point to the pixel point to be calculated; substituting the Gaussian kernel radius and the standard deviation, and calculating the weight of each pixel point using the Gaussian function formula to obtain a plurality of weights; and normalizing the plurality of weights to obtain a weight array with a sum of 1.
[0009] In some embodiments, the second texture data is edge data.
[0010] In some embodiments, the blurring the second frame using the weight array comprises: traversing pixel information around a pixel point to be calculated, and performing convolution blurring with the weight array.
[0011] In some embodiments, the blurring the second frame using the weight array comprises: detecting a boundary by calculating a gradient of each pixel point in the second frame to obtain edge data.
[0012] In some embodiments, the weight array is calculated using a CPU.
[0013] A second aspect of the present application provides an electrical equipment, comprising: a memory and a processor, the memory stores computer program instructions, and the processor implements the steps of the video image processing method when executing the computer program instructions.
[0014] A third aspect of the present application provides a non-volatile computer readable storage medium, which stores computer program instructions, and the computer program instructions are executed by a processor to implement the steps of the video image processing method.
[0015] A fourth aspect of the present application provides a computer program product, comprising a computer program, and the computer program is executed by a processor to implement the steps of the video image processing method.
[0016] Additional aspects and advantages of the present application will be made apparent from the following description. BRIEF DESCRIPTION OF DRAWINGS
[0017] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following will briefly introduce the drawings needed to be used in the embodiment description. Obviously, the drawings in the following description are only some embodiments of the present application, and other drawings can also be obtained by those skilled in the art without creative labor on the basis of these drawings.
[0018] In order to more completely understand the present application and its beneficial effects, the following will be described in conjunction with the drawings, wherein the same reference numerals in the following description represent the same parts.
[0019] Figure 1a is a schematic diagram of a system for running a video image processing method provided by an embodiment of the present application;
[0020] Figure 1b is a schematic diagram of an electrical equipment provided by an embodiment of the present application;
[0021] Figure 2 is a flowchart of a video image processing method provided by an embodiment of the present application;
[0022] Figure 3 This is a flowchart of blur processing in a video image processing method provided in another embodiment of this application;
[0023] Figure 4 This is a flowchart of adjusting the Gaussian kernel radius according to the frame rate of a video image, provided in one embodiment of this application;
[0024] Figure 5 This is a flowchart illustrating the calculation of a weight array for a Gaussian kernel based on the kernel radius and standard deviation, provided in one embodiment of this application.
[0025] Figure 6 This is a flowchart illustrating the use of a weight array to blur a second frame, as provided in one embodiment of this application.
[0026] Figure 7 This is a flowchart of a video image processing method provided in another embodiment of this application;
[0027] Figure 8 This is a schematic diagram of edge detection provided in one embodiment of this application;
[0028] Figure 9a This is a scene rendering of an embodiment of this application where the video image processing method is not enabled;
[0029] Figure 9b This is a scene effect diagram of a video image processing method enabled in one embodiment of this application;
[0030] Figure 10a This is a rendering of a vehicle without video image processing enabled according to an embodiment of this application;
[0031] Figure 10b This is a rendering of a vehicle with video image processing enabled according to an embodiment of this application;
[0032] Figure 11a This is a schematic diagram of system memory usage in an embodiment of this application where the video image processing method is not enabled;
[0033] Figure 11b This is a schematic diagram of system memory usage with video image processing method enabled according to an embodiment of this application;
[0034] Figure 12a This is a schematic diagram of system GPU usage in an embodiment of this application where the video image processing method is not enabled;
[0035] Figure 12b This is a schematic diagram of system GPU usage with a video image processing method enabled in one embodiment of this application. Detailed Implementation
[0036] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application may also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods have been omitted so as not to obscure the description of this application with unnecessary detail.
[0037] To illustrate the technical solution described in this application, specific embodiments are provided below.
[0038] Figure 1a It shows Figure 1a This is a schematic diagram of a system for running a video image processing method according to an embodiment of this application, which includes a GPU and a CPU, as well as a Native layer and a business application layer. As a more detailed example of a system for running a video image processing method, Figure 1b This is a schematic diagram of an electrical device provided in one embodiment of this application, wherein:
[0039] C++ layer: generally refers to the native layer of the Android system or Android APP, which mainly uses C++ to implement local services and link libraries;
[0040] Android App: Refers to specific business applications within the Android system.
[0041] Rendering module: This refers to the module in an Android app / system that implements specific rendering requirements. This includes implementing requirements such as texture mapping, lighting, shadows, and post-processing effects.
[0042] Performance modules: These are modules in Android apps / systems that adjust performance-related parameters and optimize time-consuming logic or code to achieve a smooth user experience. This includes addressing issues such as lag, loading time, memory usage, and jitter.
[0043] Rendering scene to texture: This refers to rendering the current content onto a texture bound to a framebuffer and storing it.
[0044] Post-rendering processing: This is a rendering process that enhances and optimizes the visual effects after the main scene has been rendered. The main changes are made to the pixel shaders.
[0045] Solid line with arrow: Direction of function interface call; the arrow points to the location of the called interface.
[0046] Dashed lines with arrows: the flow of adjustment data in the performance module.
[0047] In some embodiments, the GPU serves as the rendering module and the CPU serves as the performance module.
[0048] like Figure 2 As shown, one embodiment of this application provides a video image processing method (Adaptive Performance Anti-Aliasing, or APAA for short, is an adaptive anti-aliasing algorithm that considers performance and image quality, including performance optimization and novel anti-aliasing techniques), comprising:
[0049] Step S201: Obtain the first texture data of the first frame of the video image;
[0050] In some embodiments, combined with Figure 1b The rendering module renders the first frame of the current video image to a texture and stores it in the texture, thus obtaining the first texture data, which is used for texture blur anti-aliasing of the first frame and subsequent texture mixing.
[0051] Step S203: Blur the second frame to obtain the second texture data;
[0052] By blurring the second frame, aliasing can be countered.
[0053] In some embodiments, step S203 may include:
[0054] Step S2031: Adjust the Gaussian kernel radius according to the frame rate of the video image, and calculate the weight array based on the Gaussian kernel radius and standard deviation;
[0055] The formula for calculating frame rate is:
[0056] (Formula 1)
[0057] Where Time is the duration of the statistical period (which can be 1 second or 5 seconds, etc.), FPS is the average frame rate within the time period, and FrameCount is the number of statistical frames within the time period.
[0058] As shown in Formula 1, the statistical period Time in this application is 1 second. A high-precision clock, std::chrono::high_resolution_clock, provided by the C++ standard library is used for timing statistics, primarily implemented on the CPU side of the performance module. In the main rendering loop, after each complete rendering loop execution, FrameCount is incremented by 1, and the current time t1 is recorded and assigned to the previous frame's time variable t2. When the system timer (t1 - t2) reaches one second, the ratio of the frame count FrameCount to the time Time is calculated to obtain the average frame rate (FPS). After calculating the average frame rate within the current second, FrameCount is reset to zero, and frame counting begins again.
[0059] Compare the calculated average frame rate (FPS) with the target frame rate (FPSgoal). For example... Figure 4 As shown, in step S2021, when the frame rate of the video image is higher than the threshold (FPS > FPSgoal), the Gaussian kernel radius is increased; in step S2022, when the frame rate of the video image is lower than the threshold (FPS < FPSgoal), the Gaussian kernel radius is decreased; of course, when the frame rate of the video image is equal to the threshold (FPS = FPSgoal), the Gaussian kernel radius remains unchanged. The Gaussian kernel radius is generally empirically between 3*3 and 15*15. Increasing the Gaussian kernel radius increases the anti-aliasing effect, but also increases performance consumption. The magnitude of the Gaussian kernel radius change is generally similar to PID control; the larger the difference between the average frame rate and the target frame rate, the larger the change magnitude, thus achieving fast convergence. However, the magnitude of the change must be an integer, and the refresh time per frame is short, so a change magnitude of 1 is sufficient.
[0060] After obtaining the Gaussian kernel radius, the Gaussian kernel standard deviation parameter is a preset parameter, generally with an empirical value of (0.5 to 10). Based on the obtained Gaussian kernel radius and the preset standard deviation, the performance module is used to calculate the weight array of the Gaussian kernel. The Gaussian kernel is a two-dimensional Gaussian distribution, and its weights decrease exponentially with distance from the center point.
[0061] (Formula 2)
[0062] Where G(x,y) is the Gaussian function value at the point (x,y); r is the radius; σ is the standard deviation, which controls the width of the Gaussian function; and e is the base of the natural logarithm, approximately 2.71828.
[0063] In some embodiments, the second texture data is the image data of the entire second frame. In some specific embodiments, the second texture data is edge data, that is, the edge data of each object in the video image, thus requiring edge detection in the second frame. In some embodiments, edge detection employs a custom operator, which detects edges by calculating the gradient of each pixel in the image to obtain edge data. Compared with traditional gradient edge detection algorithms, this operator ensures faster detection speed and higher detection accuracy. This is because the operator's numbers are relatively smaller, making computation faster, but the operator's weights are larger, making it more sensitive to edge detection. This operator mainly uses two 3x3 convolution kernels to calculate gradients along the horizontal and vertical directions respectively, thereby obtaining the gradient magnitude and direction of the image.
[0064] (Formula 3)
[0065] (Formula 4)
[0066] (Formula 5)
[0067] (Formula 6)
[0068] in, It is the horizontal convolution kernel of this operator; is the vertical convolution kernel of the operator; Grad is the gradient magnitude.
[0069] As shown in formulas (3) and (4), by convolving the color values of the corresponding coordinate points in the vertical and horizontal directions, we obtain... and The gradient magnitude can then be calculated using formula (5) or formula (6). Finally, by comparing the gradient magnitude of each pixel with the target gradient magnitude, it is determined whether it is a boundary point / edge.
[0070] Step S2032: Use a weight array to blur the second frame to obtain the second texture data.
[0071] In some embodiments, when an edge is detected, a Gaussian blur convolution operation is performed using a weight array. The weight array is multiplied and summed with the pixel value of the corresponding point, and then normalized to obtain the blurred pixel value of that point. Figure 8 As shown, when a thin line less than one pixel wide is detected, the boundary line will break, even after blurring.
[0072] There is a breakage phenomenon, so off-screen rendering and increased texture blending are used to mitigate the breakage of fine lines. The set of pixel blur values at each point constitutes the second texture data. To reduce spatial breakage and jagged edges, such as... Figure 6 As shown, in step S2051, in some embodiments, the pixel information surrounding the current pixel is traversed and convolved with the corresponding Gaussian weight array to blur, thereby reducing the jagged edges of the image caused by low resolution and other reasons.
[0073] (Formula 7)
[0074] Where Color is the final color value written; Colorcur_fuzzy is the color value of the current frame scene texture post-processing blur; K(i,j) is the Gaussian weight value at pixel texture coordinate (i,j); and Color(i,j) is the pixel color value at texture coordinate (i,j).
[0075] Step S205: Mix the first texture data and the second texture data and output the video image.
[0076] Specifically, during the movement of objects in a video image, the position of the edge break changes along the entire edge line, resulting in some jitter. By rendering the first frame of the scene to a texture and storing it in step 201, and then mixing it with the texture information of the second frame with a certain weight ratio, the pixel information of both frames is considered. This reduces abrupt changes in pixel information at the same location during movement, making the broken lines and jagged edges smoother. Motion blur is achieved through linear blending. To improve anti-aliasing performance, pixel blur is applied only to pixels detected as edges, thus improving performance while achieving anti-aliasing. When a detected point is not an edge, the texture color value is directly returned; when a detected point is an edge, the color information of the surrounding pixels is first convolved with Gaussian weights, the weights are accumulated, the resulting convolution is normalized, and then the texture color value rendered from the first frame and stored in the scene is linearly blended with the color value obtained from the Gaussian blur of the current frame.
[0077] (Formula 8)
[0078] In the formula, Color is the final color value written; Colorpre is the base color value rendered to the scene in the first frame; Colorcur_fuzzy is the color value obtained according to Formula 7; and k1 is the temporal blending coefficient value.
[0079] The video image processing method in this embodiment only requires adjusting two parameters and blending the texture of the previous frame with the texture of the current frame to optimize breakage and reduce jitter.
[0080] Furthermore, in some embodiments, the second texture data is edge data, and a custom edge detection algorithm is used for edge detection, which is more accurate than the classic Sobel operator detection and more accurate than the classic Scharr operator detection.
[0081] In some embodiments, such as Figure 3 As shown, before blurring the second frame using the weight array of the Gaussian kernel, the following steps are also included:
[0082] like Figure 5 As shown, in some embodiments, the weight array for calculating the Gaussian kernel includes:
[0083] Step S311: Create a coordinate system with the pixel to be calculated as the origin, and the positive and negative coordinate ranges are both the Gaussian kernel radius;
[0084] Step S312: Calculate the squared distance from each pixel to the pixel to be calculated;
[0085] Step S313: Substitute the Gaussian kernel radius and standard deviation, and use the Gaussian function formula to calculate the weight of each pixel, obtaining multiple weights; and
[0086] Step S314: Normalize multiple weights to obtain a weight array that sums to 1.
[0087] In some embodiments, the CPU of the performance module is used to perform the above calculations.
[0088] Figure 7 The flowchart below illustrates a video image processing method provided in another embodiment of this application.
[0089] Figure 9a This is a scene rendering of an embodiment of this application where the video image processing method is not enabled. Figure 9b This is a scene effect diagram of an embodiment of the present application where the video image processing method has been enabled. The diagram includes traffic cones, a vehicle, other vehicles, and obstacles. It can be seen that the image quality of each item is significantly improved before and after enabling the video image processing method.
[0090] Figure 10a This is a rendering of a vehicle without video image processing enabled according to an embodiment of this application. Figure 10b This is a rendering of a vehicle with the video image processing method enabled according to an embodiment of this application. It can be seen that the image effect of the vehicle is significantly improved before and after enabling the video image processing method.
[0091] The above two comparisons demonstrate that the video image optimization method presented in this application outperforms the method without anti-aliasing, resulting in a smoother, more uniform image with better quality. Detailed comparisons can be made by zooming in on the examples, especially the comparison of the effects on complex vehicles.
[0092] Table 1 Performance and image quality of different anti-aliasing algorithms
[0093] Anti-aliasing algorithm Performance Picture quality No anti-aliasing algorithm Generally Poor Fast Approximate Anti-Aliasing (FXAA) Poor Better APAA Better Better
[0094] As shown in Table 1, the APAA anti-aliasing effect and performance of this application have reached a good state, and its overall performance is better than that of FXAA.
[0095] Figure 11a This is a schematic diagram of system memory usage (925.9M) in one embodiment of this application where the video image processing method is not enabled. Figure 11b This is a schematic diagram of system memory usage (932.2M) with the video image processing method enabled in one embodiment of this application. It can be seen that the difference in memory usage before and after enabling the video image processing method is very small.
[0096] Figure 12a This is a schematic diagram of system GPU usage in an embodiment of this application where the video image processing method is not enabled. Figure 12bThis is a schematic diagram of system GPU usage with video image processing method enabled according to an embodiment of this application. It can be seen that the GPU usage remains at 40% before and after enabling the video image processing method, with no change.
[0097] This application, APAA, provides a novel anti-aliasing method that considers both performance and image quality through adaptive control parameters. The algorithm can be used to optimize rendering performance in the native layer of Android systems or Android apps, exhibiting a degree of versatility. Compared to existing technologies, this application uses fewer parameters and adaptively and intelligently adjusts image quality, as shown in Table 1, optimizing both performance and image quality according to requirements. The algorithm performs some calculations in the pixel shader, eliminating hardware dependence and minimizing resource consumption; additional weight calculations are offloaded to the CPU, reducing GPU load.
[0098] In some embodiments, this application also provides an electrical device, including: a memory and a processor, wherein the memory stores computer program instructions, and the processor executes the computer program instructions to implement the steps of the aforementioned video image processing method. In some embodiments, the structure of the electrical device may be as follows: Figure 1b As shown, the processor includes a rendering module (GPU) and a performance module (CPU).
[0099] This application also provides a non-volatile computer-readable storage medium storing a computer program. The computer program, when executed by a processor, implements the video image processing method described above. The storage medium uses a solid-state drive (SSD) and is stored in a binary executable file format. The program includes multi-threaded processing modules responsible for image acquisition, signal processing, pixel data processing, and result output, respectively.
[0100] This application also provides a computer program product, characterized in that it includes a computer program, which, when executed by a processor, implements the steps of the video image processing method described above. The program product is distributed as a software package, containing a dynamic link library (DLL) and configuration files. Users can call the video image processing functions through an API interface, supporting integration with autonomous driving systems and industrial robots.
[0101] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.
[0102] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is merely an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. Furthermore, the specific names of the functional units and modules are only for easy differentiation and are not intended to limit the scope of protection of this application. The specific working process of the units and modules in the above system can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.
[0103] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.
[0104] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.
[0105] In the embodiments provided in this application, it should be understood that the disclosed devices / terminal equipment and methods can be implemented in other ways. For example, the device / terminal equipment embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the displayed or discussed mutual coupling or direct coupling or communication connection may be through some interfaces; the indirect coupling or communication connection between devices or units may be electrical, mechanical, or other forms.
[0106] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.
[0107] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.
[0108] If the integrated module / unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying the computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium can be appropriately added or removed according to the requirements of legislation and patent practice in the jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, computer-readable media do not include electrical carrier signals and telecommunication signals.
[0109] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application 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 of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.
Claims
1. A video image processing method, characterized in that, include: Obtain the first texture data of the first frame of the video image; The second frame is blurred to obtain the second texture data; as well as The first texture data and the second texture data are mixed and the video image is output.
2. The video image processing method according to claim 1, characterized in that, The process of blurring the second frame to obtain the second texture data includes: The Gaussian kernel radius is adjusted according to the frame rate of the video image, and a weight array is calculated based on the Gaussian kernel radius and the standard deviation; and The second frame is blurred using the weight array to obtain the second texture data.
3. The video image processing method according to claim 2, characterized in that, Adjusting the Gaussian kernel radius according to the frame rate of the video image includes: When the frame rate of the video image is higher than a threshold, increase the radius of the Gaussian kernel; and / or When the frame rate of the video image is lower than a threshold, the radius of the Gaussian kernel is reduced.
4. The video image processing method according to claim 2, characterized in that, The calculation of the weight array based on the Gaussian kernel radius and standard deviation includes: Create a coordinate system with the pixel to be calculated as the origin, and the positive and negative coordinates are both within the radius of the Gaussian kernel; Calculate the squared distance from each pixel to the pixel to be calculated; Substituting the Gaussian kernel radius and the standard deviation, the weights of each pixel are calculated using the Gaussian function formula, resulting in multiple weights; and The multiple weights are normalized to obtain the weight array whose sum is 1.
5. The video image processing method according to claim 1, characterized in that, The second texture data is edge data.
6. The video image processing method according to claim 5, characterized in that, The process of blurring the second frame using the weight array includes: Iterate through the pixel information surrounding the pixel to be calculated and perform convolution blurring with the weight array.
7. The video image processing method according to claim 5, characterized in that, The process of blurring the second frame using the weight array includes: The edge data is obtained by detecting the boundary by calculating the gradient of each pixel in the second frame.
8. The video image processing method according to claim 5, characterized in that, The weight array is calculated using the CPU.
9. An electrical appliance, characterized in that, include: A memory and a processor, the memory storing computer program instructions, the processor executing the computer program instructions to implement the steps of the video image processing method according to any one of claims 1-8.
10. A non-volatile computer-readable storage medium storing computer program instructions thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the steps of the video image processing method according to any one of claims 1-8.
11. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the video image processing method according to any one of claims 1-8.