Rendering abnormity automatic diagnosis system based on UE5 pixel backward reading and OpenCV

Abstract

The invention discloses a rendering anomaly automatic diagnosis system based on UE5 pixel backward reading and OpenCV. The rendering anomaly automatic diagnosis system comprises a pipeline extension layer, a data capture layer and an intelligent analysis layer. Wherein the pipeline extension layer is used for constructing a rendering pipeline extension model and collecting RenderTarget data; the data capturing layer is used for realizing RenderTarget asynchronous reading by adopting a double-buffering mechanism; and the intelligent analysis layer constructs a multi-dimensional anomaly detection model based on OpenCV and analyzes the image data to obtain an anomaly analysis result. According to the scheme, multi-modal anomaly detection and diagnosis are realized by constructing a three-layer architecture of rendering pipeline extension-intermediate result capture-intelligent analysis and decision, and nine anomaly types such as performance bottleneck, visual defects and rendering logic errors can be covered. By inserting customized Debug rendering Pass, a rendering intermediate result is captured in real time, and intelligent diagnosis of rendering defects is realized in combination with a computer vision algorithm.

Description

Technical Field

[0001] The present invention belongs to the field of computer graphics, and in particular relates to an automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV. Background Art

[0002] In fields such as digital content creation (DCC), virtual reality (VR / AR), and building information modeling (BIM), debugging complex rendering pipelines faces significant challenges. Traditional debugging methods that rely on manual frame capture have three major pain points:

[0003] 1. Multi-factor coupling: Rendering anomalies may be caused by the interaction of multiple links such as shader code, material parameters, geometric topology, and lighting settings.

[0004] 2. Non-deterministic manifestations: Certain abnormal phenomena (such as Z-fighting) have randomness and time-series correlation.

[0005] 3. Long debugging cycle: A typical project can take up to 8-12 hours to debug the entire process.

[0006] The existing technical solutions have obvious limitations, mainly the following:

[0007] 1. The built-in diagnostic tools of commercial engines have limited functions (for example, the UE5 Frame Debugger only supports single-frame static analysis).

[0008] 2. Third-party performance analysis software (such as PIX and RenderDoc) lacks intelligent exception recognition capabilities.

[0009] 3. The detection rate of traditional rule-matching algorithms for complex abnormal patterns is less than 43%. Summary of the Invention

[0010] The technical problem to be solved by the present invention is to provide an automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV, which solves the problem of single function and low detection rate of traditional diagnosis systems in the prior art.

[0011] The present invention adopts the following technical solutions to solve the above technical problems:

[0012] The automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV includes a pipeline extension layer, a data capture layer, and an intelligent analysis layer. The pipeline extension layer builds a rendering pipeline extension model and collects RenderTarget data. The data capture layer uses a double buffering mechanism to implement asynchronous reading of RenderTarget. The intelligent analysis layer builds a multi-dimensional anomaly detection model based on OpenCV, analyzes image data, and obtains anomaly analysis results.

[0013] The rendering pipeline extension model includes the implantation of three types of customized passes into the UE5 standard rendering process, namely:

[0014] Geometry tag Pass, used to record the RGBA encoding information of the model instance ID / material ID;

[0015] Performance probe pass, used to insert GPU timestamp markers during key rendering stages;

[0016] Feature enhancement pass is used to enhance the visual features of potential abnormal areas.

[0017] The specific process of collecting RenderTarget data is as follows:

[0018] First, add a custom DebugPass after a specific rendering Pass according to different requirements; secondly, collect the RenderTarget of the custom and UE built-in DebugPass and normal rendering Pass.

[0019] The data capture layer reads back the collected data in the RenderTarget and saves it to the UTexture2D object; and uses the data in the UTexture2D to create a corresponding cv::mat object.

[0020] The process of analyzing the image data includes:

[0021] Detection of scene color anomalies before post-processing, drastic changes in the same position between consecutive frames, screen tearing detection, detection of semi-transparent rendering sorting anomalies, and rendering artifact detection.

[0022] Drastic changes in the same position between consecutive frames include screen flicker and moiré patterns, which are detected by combining inter-frame difference method and optical flow method.

[0023] Rendering artifact detection includes aliasing and moiré patterns. Edge detection and frequency analysis methods are used to detect edge sharpness, and artifacts are detected through frequency domain transformation.

[0024] It also includes a performance anomaly analysis module. The specific analysis process is as follows:

[0025] Insert GPU time query instructions between each DrawCall to obtain the execution time of each DrawCall, and convert the data into color and write it into the corresponding pixel, accumulating it in each DrawCall. Finally, by observing the generated image, we can determine the pixels that consume too much energy, and obtain the materials or models that may cause performance abnormalities through the correspondence between the pre-generated pixels and the models and materials.

[0026] Compared with the prior art, the present invention has the following beneficial effects:

[0027] 1. This solution implements multimodal anomaly detection and diagnosis by building a three-layer architecture of "rendering pipeline extension - intermediate result capture - intelligent analysis and decision-making", which can cover nine major types of anomalies, including performance bottlenecks, visual defects, and rendering logic errors.

[0028] 2. By inserting a customized debug rendering pass, capturing intermediate rendering results in real time, and combining computer vision algorithms, intelligent diagnosis of rendering defects is achieved.

[0029] 3. This solution can perform spatiotemporal correlation analysis: dynamic anomaly tracking is achieved through inter-frame difference + optical flow tracking; root cause location accuracy: anomaly tracing is achieved at the model / material / shader granularity.

[0030] 4. The system has real-time diagnostic capabilities: it supports online detection at a frame rate of 120fps.

[0031] 5. You can skip the original complicated manual debugging steps (abnormal reproduction - capture single-frame rendering data - analysis of rendering data) and automatically analyze the entire rendering process.

[0032] 6. Ability to analyze anomalies across multiple frames. The original analysis process can only analyze data from a single frame. If the anomaly is not caused by the current frame, it is difficult to locate it. This solution can locate the source of anomalies caused by non-current frames through continuous multi-frame data analysis, such as material flickering or afterimages.

[0033] 7. High positioning accuracy. By marking models and materials with pixels, the positioning accuracy of abnormal causes is improved to a single material or model, reducing the troubleshooting time. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] Figure 1 This is an architecture diagram of the automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV in the present invention.

[0035] Figure 2 This is a comparison chart of the automatic diagnosis effects of rendering anomalies based on UE5 pixel readback and OpenCV in the present invention. DETAILED DESCRIPTION

[0036] The structure and working process of the present invention will be further described below with reference to the accompanying drawings.

[0037] This solution implements anomaly diagnosis by building a three-layer architecture of "rendering pipeline extension-intermediate result capture-intelligent analysis and decision-making". Specifically, the automatic rendering anomaly diagnosis system based on UE5 pixel readback and OpenCV (image analysis library) includes a pipeline extension layer, a data capture layer, and an intelligent analysis layer. Among them, the pipeline extension layer builds a rendering pipeline extension model and collects RenderTarget (rendering target, used to store images of rendering data) data; the data capture layer uses a double buffering mechanism to implement asynchronous reading of RenderTarget; the intelligent analysis layer builds a multi-dimensional anomaly detection model based on OpenCV, analyzes image data, and obtains anomaly analysis results.

[0038] Specific embodiments, such as Figure 1 、 Figure 2 As shown:

[0039] The rendering anomaly automatic diagnosis system based on UE5 pixel readback and OpenCV includes pipeline extension layer, data capture layer and intelligent analysis layer;

[0040] 1. Pipeline extension layer: Three types of customized passes are embedded in the UE5 standard rendering process:

[0041] Geometry Mark Pass: records the RGBA encoding information of the model instance ID / material ID. The specific operation process is as follows:

[0042] Insert a custom geometry tag Pass in the PostBasePass (after the base pass) of the UE5 rendering pipeline. This Pass traverses all model instances currently rendered, generates a unique ID code for each instance (such as the model ID is 0x00FF, the material ID is 0x0F00), and converts it into an RGBA color value (the lower 8 bits of the model ID map to the R channel, and the upper 8 bits map to the G channel; the lower 8 bits of the material ID map to the B channel, and the highest bit is reserved to map to the A channel).

[0043] The encoding rules need to be defined in advance (for example, ID = (ModelID(Model ID)<<16)|(MaterialID(Material ID)<<8), corresponding to R=ModelID&0xFF, G=(ModelID>>8)&0xFF, B=MaterialID&0xFF, A=0xFF).

[0044] Example:

[0045] Assuming the model ID is 1024 (hexadecimal 0x0400) and the material ID is 255 (hexadecimal 0x00FF), the encoded RGBA value is:

[0046] R = 1024 & 0xFF = 0x00,

[0047] G = (1024 >> 8) & 0xFF = 0x04,

[0048] B = 255 & 0xFF = 0xFF,

[0049] A = 0xFF (opaque) Finally, all pixels of this model instance will be marked as (0x00, 0x04, 0xFF, 0xFF) (blue).

[0050] Performance Probe Pass: Insert GPU timestamp markers during key rendering phases. The specific operation process is as follows:

[0051] Performance probe passes are inserted into key rendering stages (such as BasePass (base data rendering pass), ShadowMapPass (shadow map rendering pass), and PostProcessPass (post-process rendering pass). Each probe inserts a timestamp marker into the GPU timeline by calling RHICmdList.WriteTimestamp() to record the GPU time when the stage starts and ends. The timestamp data is stored in a pre-allocated GPU timestamp buffer (size N × 8 bytes, where N is the maximum number of probes).

[0052] Example:

[0053] Assume that probe 1 is inserted at the beginning of BasePass and probe 2 is inserted at the end; probe 3 is inserted at the beginning of PostProcessPass; the timestamp sequence recorded by the GPU timeline is [T0, T1, T2, T3], where:

[0054] T0: BasePass start time,

[0055] T1: BasePass end time → BasePass duration = T1 - T0,

[0056] T2: PostProcessPass start time,

[0057] T3: PostProcessPass end time → PostProcessPass duration = T3 - T2.

[0058] Data association: Through the UE5 DrawCall (draw call, which refers to rendering a model to the screen) index (each DrawCall corresponds to the rendering instruction of a model instance), the timestamp is bound to the specific DrawCall. Later, the DrawCall that takes too long and its associated model / material can be located.

[0059] Feature Enhancement Pass: Enhances the visual features of potentially abnormal areas (such as highlights and shadows). The specific operation process is as follows:

[0060] For areas prone to anomalies (such as highlights, shadows, and transparent edges), a feature enhancement pass is inserted into the rendering pipeline to enhance the color values ​​of these areas by adjusting the shader logic:

[0061] Highlight area: Extract the Z component of the normal map (indicating the surface orientation). If the angle between the normal and the line of sight is less than 15° (i.e. close to the direction of specular reflection), increase the brightness of the area by 30% (Color.rgb *= 1.3).

[0062] Shadow area: Extract the gradient of the depth map (DepthGradient = dDepth / dx + dDepth / dy). If the gradient is greater than the threshold (indicating the edge of a shadow), increase the contrast of that area by 20% ((Color - 0.5) * 1.2 + 0.5).

[0063] Transparent edge: Extract the gradient of the alpha channel (AlphaGradient = dAlpha / dx + dAlpha / dy). If the gradient is greater than the threshold (indicating a semi-transparent edge), increase the saturation of the area by 40% (Color.rgb = saturate(Color.rgb * 1.4)).

[0064] Example:

[0065] A character model's metal helmet produces highlights under illumination. The original highlight area brightness is (1.0, 0.9, 0.8). After the feature enhancement pass, the brightness is increased by 30% to (1.3, 1.17, 1.04). (Due to the HDR range, it is actually truncated to (1.0, 1.0, 1.0)). However, the brighter highlight area's outline is easier to identify in subsequent analysis modules.

[0066] 2. Data capture layer: Use double buffering mechanism to implement RenderTarget asynchronous reading. The specific implementation process is as follows:

[0067] First, get the RenderTarget (backend buffer) of the scene capture component and submit an asynchronous read task to the GPU command queue; get the RHI texture resource of the RenderTarget (the texture in the GPU memory); then, perform the pixel data read operation, create a temporary CPU-readable texture (confirm the memory size through RHIGetTextureMemorySize), copy the contents of the RenderTarget to the temporary texture (copy within the GPU, without blocking the CPU); finally, map the temporary texture data to the CPU memory (lock the texture and get the pointer).

[0068] Collect custom and UE built-in DebugPass and normal rendering Pass RenderTarget. This collection process will last for multiple frames to detect abnormal changes between consecutive frames.

[0069] The C++ sample code is as follows:

[0070] / / UE5 C++ example code

[0071] Get the RenderTarget (back buffer) of the scene capture component

[0072] TSharedPtr <frendertarget>RenderTarget =

[0073] SceneCaptureComponent->TextureTarget;

[0074] Submit asynchronous read tasks to the GPU command queue

[0075] ENQUEUE_RENDER_COMMAND(CaptureRenderTargetCommand)(

[0076] [RenderTarget](FRHICommandListImmediate& RHICmdList)

[0077] {

[0078] Get the RenderTarget's RHI texture resource (the texture in GPU memory)

[0079] FTexture2DRHIRef TextureRHI = RenderTarget->GetRenderTargetResource()->GetRenderTargetTexture();

[0080] / / Execute pixel data reading operation

[0081] Create a temporary CPU-readable texture (confirm the memory size via RHIGetTextureMemorySize)

[0082] FTexture2DRHIRef ReadbackTexture = RHICreateTexture2D();

[0083] Copy the contents of the RenderTarget to a temporary texture (intra-GPU copy, no CPU blocking)

[0084] RHICmdList.CopyToResolveTarget(TextureRHI, ReadbackTexture,FResolveParams());

[0085] Map temporary texture data to CPU memory (lock texture, get pointer)

[0086] void* DataPtr;

[0087] uint32 Pitch;

[0088] RHICmdList.LockTexture(ReadbackTexture->TextureRHI,0, FRHIGPUFence(),false);

[0089] FTexture2DRHI::GetRenderTargetData(ReadbackTexture, DataPtr, Pitch);

[0090] });

[0091] 3. Intelligent analysis layer: Build a multi-dimensional anomaly detection model based on OpenCV. The anomaly detection model analyzes the image data. The specific analysis process and implementation code are as follows:

[0092] # OpenCV core processing flow (Python pseudocode)

[0093] def analyze_frame(mat_frame):

[0094] # Performance anomaly detection module

[0095] drawcall_heatmap = generate_drawcall_heatmap(mat_frame)

[0096] Function:

[0097] Map the GPU rendering pipeline's DrawCall time-consuming data into a visual heat map to quickly locate time-consuming DrawCalls and their associated models / materials.

[0098] Operation process:

[0099] Data input: Receive the original rendering frame mat_frame (RGBA format), and the DrawCall time-consuming data collected by the performance probe Pass (structure is TMap<int32, float> , the key is the DrawCall index, and the value is the time consumed (ms).

[0100] Data normalization:

[0101] Count the minimum (t_min) and maximum (t_max) time consumed by all DrawCalls and calculate the normalization coefficient:

[0102] scale = 1.0 / (t_max - t_min) (set to 1.0 if t_max == t_min).

[0103] For each DrawCall duration t, calculate the normalized value: normalized_t = (t - t_min) * scale (range: 0~1).

[0104] Color Mapping:

[0105] Use the heat map color table (Jet color map) to map the normalized values ​​to RGB colors:

[0106] normalized_t ∈ [0, 0.33]: blue (low cost) → (0, 0, 255 * (1 - 3*normalized_t));

[0107] normalized_t ∈ [0.33, 0.66]: cyan → purple transition → (0, 255*(3*normalized_t- 1), 255*(1.5 - 3*|normalized_t - 0.5|));

[0108] normalized_t ∈ [0.66, 1]: Yellow → Red (high time consumption) → (255*(3*normalized_t -2), 255*(2 - 3*normalized_t), 0).

[0109] Heatmap overlay:

[0110] The color corresponding to the DrawCall time consumption is filled into the Alpha channel or a separate channel of the original frame according to the pixel area covered by the DrawCall (the mapping relationship between the model ID / material ID and pixel coordinates recorded by the geometric marker Pass) to generate a heat map overlay.

[0111] # Rendering quality detection module (i.e. analyzing image data)

[0112] exposure_defects = detect_exposure_issue(mat_frame)

[0113] Function 1: Detect areas in an image with abnormal pixel values ​​caused by excessive or insufficient lighting (overexposure: pixel values ​​close to 255; underexposure: pixel values ​​close to 0).

[0114] Operation process:

[0115] Channel separation: Separate the input frame mat_frame into R, G, and B single channels (cv::split).

[0116] Histogram statistics:

[0117] Calculate the 256-level grayscale histogram (cv::calcHist) for each channel and count the number of pixels at each brightness level (0~255).

[0118] Calculate the ratio of highlight pixels (number of pixels with brightness ≥ 224 / total number of pixels) and dark pixel ratio (number of pixels with brightness ≤ 32 / total number of pixels) for each channel.

[0119] Threshold determination:

[0120] Overexposure trigger condition: The proportion of highlight pixels in any channel is greater than 15% (empirical threshold, adjustable based on training data).

[0121] Underexposure trigger condition: The proportion of dark pixels in any channel is greater than 15%.

[0122] Area Marking:

[0123] For overexposed areas: binarize the highlight pixels of the R / G / B channels (cv::threshold, threshold = 224) and extract the coordinate set.

[0124] For underexposed areas: Similarly, extract the pixel coordinate set with brightness ≤ 32.

[0125] Result output: Returns the mask of the overexposed / underexposed area (cv::Mat format, the abnormal area is 255, the rest is 0) and the percentage data.

[0126] Function 2: Detect drastic changes in the same position between consecutive frames (screen flicker, moiré).

[0127] Inter-frame difference method: calculate the absolute difference between adjacent frames and extract areas with large brightness changes.

[0128] Optical flow method: tracks brightness changes in moving areas.

[0129] Function three: Screen tearing detection, detects screen misalignment caused by vertical synchronization failure.

[0130] Upper and lower half frame comparison: Divide each frame into two parts, and calculate the difference between the two parts.

[0131] Edge matching: Use Canny edge detection to detect the continuity of upper and lower edges.

[0132] transparency_artifact = detect_transparency_artifact(mat_frame)

[0133] Function 4: Detect defects such as black edges and color discontinuities on translucent objects caused by incorrect rendering order.

[0134] Operation process:

[0135] Semi-transparent area extraction:

[0136] Based on the alpha channel threshold (such as Alpha < 0.9), extract the semi-transparent area (cv::Mat format, transparent area is 255) through cv::inRange.

[0137] Correct rendering result generation (OIT pre-rendering):

[0138] Re-render translucent objects using the linked list OIT algorithm (Order Independent Transparency):

[0139] A depth linked list is maintained in the GPU for each translucent fragment, sorted from back to front by depth.

[0140] Blend the colors in sorted order (FinalColor = AccumulatedColor + CurrentColor *CurrentAlpha).

[0141] Align the OIT pre-rendered result (cv::Mat format) with the original rendering frame (mapping coordinates by the model ID of the geometry tag Pass).

[0142] Difference comparison:

[0143] Calculate the mean square error (MSE) between the original frame and the OIT pre-rendered result:

[0144] Set a threshold (such as MSE>50) and mark the area where the MSE exceeds the threshold as a semi-transparent defect.

[0145] Result output: Returns the mask and MSE value of the defect area. The specific implementation code is as follows:

[0146] return {"performance": drawcall_heatmap,

[0147] "quality": {

[0148] "exposure": exposure_defects,

[0149] "transparency": transparency_artifact}}

[0150] Function 5: Rendering artifact detection (aliasing, moiré)

[0151] Edge detection + frequency analysis: Use Sobel / Canny to detect edges and analyze their sharpness (jaggies appear as short, broken edges).

[0152] Frequency domain transformation: The image is transformed into the frequency domain through FFT. The concentrated peaks in the high-frequency area may correspond to artifacts.

[0153] This part also includes a performance anomaly analysis module.

[0154] Insert GPU time query instructions between each DrawCall to obtain the execution time of each DrawCall, convert the data into color and write it into the corresponding pixel, and accumulate it in each DrawCall. Finally, by observing the generated image, you can determine the pixels that consume too much energy, and you can quickly obtain the materials or models that may cause performance abnormalities through the correspondence between the pre-generated pixels and the models and materials.

[0155] Function 6: Real-time detection and analysis of data

[0156] Integrate the entire module into the rendering process of UE5, and control the activation and deactivation of the module through instructions, so as to realize real-time data analysis while the program is running. There is no need to record data at runtime and perform data analysis offline as in traditional solutions.

[0157] The above process is executed regularly for analysis, the analysis results are collected, a visual diagnostic report is generated, and the abnormal repair work order system is triggered.

[0158] Through the above embodiments and the attached Figure 2 As shown, it can be seen that this solution also has the following effects:

[0159] You can skip the original complicated manual debugging steps (exception reproduction - capture single-frame rendering data - analysis of rendering data) and automatically analyze the entire rendering process.

[0160] The ability to analyze anomalies across multiple frames. The original analysis process can only analyze data from a single frame. If the anomaly is not caused by the current frame, it is difficult to locate it. This solution can locate the source of anomalies not caused by the current frame through continuous multi-frame data analysis, such as material flickering or afterimages.

[0161] The positioning accuracy is high. By marking models and materials with pixels, the positioning accuracy of the abnormal cause is improved to a single material or model, reducing the troubleshooting time.

[0162] In the above examples, the programming code parts, formats and symbols used are all commonly used writing methods of programming codes, which mainly serve as identification or explanation, and can be replaced by other methods. Technical personnel in this field can understand their meanings without any objection and will not cause any unclear problems.

[0163] Those skilled in the art should understand that they can implement variations by combining the prior art and the above embodiments. Such variations do not affect the essence of this solution and are not described in detail here.

[0164] It should be understood that this solution is not limited to the specific implementation methods described above. Devices and structures not described in detail should be understood to be implemented in a common manner in the art. Any person skilled in the art can, without departing from the scope of this solution, use the methods and technical content disclosed above to make many possible changes and modifications to this solution, or modify it into equivalent embodiments with equivalent changes, without affecting the essence of this solution. Therefore, any simple modifications, equivalent changes, and modifications made to the above embodiments based on the technical essence of this solution without departing from the content of this solution are still within the scope of protection of this solution.< / frendertarget>

Claims

1. An automated rendering anomaly diagnosis system based on UE5 pixel readback and OpenCV, featuring: It includes pipeline extension layer, data capture layer and intelligent analysis layer; the pipeline extension layer builds a rendering pipeline extension model and collects RenderTarget data; the data capture layer uses a double buffering mechanism to implement asynchronous reading of RenderTarget; the intelligent analysis layer builds a multi-dimensional anomaly detection model based on OpenCV, analyzes image data, and obtains anomaly analysis results.

2. The automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV according to claim 1, characterized in that: The rendering pipeline extension model includes the implantation of three types of customized passes into the UE5 standard rendering process, namely: Geometry tag Pass, used to record the RGBA encoding information of the model instance ID / material ID; Performance probe pass, used to insert GPU timestamp markers during key rendering stages; Feature enhancement pass is used to enhance the visual features of potential abnormal areas.

3. The automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV according to claim 2, characterized in that: The specific process of collecting RenderTarget data is as follows: First, add a custom DebugPass after a specific rendering Pass according to different requirements; secondly, collect the RenderTarget of the custom and UE built-in DebugPass and normal rendering Pass.

4. The automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV according to claim 3, characterized in that: The data capture layer reads back the collected data in the RenderTarget and saves it to the UTexture2D object; and uses the data in the UTexture2D to create a corresponding cv::mat object.

5. The automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV according to claim 4 is characterized in that: The process of analyzing the image data includes: Detection of scene color anomalies before post-processing, drastic changes in the same position between consecutive frames, screen tearing detection, detection of semi-transparent rendering sorting anomalies, and rendering artifact detection.

6. The automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV according to claim 5, characterized in that: Drastic changes in the same position between consecutive frames include screen flicker and moiré patterns, which are detected by combining inter-frame difference method and optical flow method.

7. The rendering anomaly automatic diagnosis system based on UE5 pixel readback and OpenCV according to claim 5, characterized in that: Rendering artifact detection includes aliasing and moiré patterns. Edge detection and frequency analysis methods are used to detect edge sharpness, and artifacts are detected through frequency domain transformation.

8. The automatic diagnosis system for rendering anomalies based on UE5 pixel readback and OpenCV according to claim 1, characterized in that: It also includes a performance anomaly analysis module. The specific analysis process is as follows: Insert GPU time query instructions between each DrawCall to obtain the execution time of each DrawCall, and convert the data into color and write it into the corresponding pixel, accumulating it in each DrawCall. Finally, by observing the generated image, we can determine the pixels that consume too much energy, and obtain the materials or models that may cause performance abnormalities through the correspondence between the pre-generated pixels and the models and materials.

Images