Method and device for displaying big data linkage instruction assembly line

Abstract

The invention relates to the field of data processing, in particular to a big data linkage instruction assembly line display method and device. The method mainly comprises the steps of obtaining a first visual image according to data to be displayed, and performing assembly line display on the first visual image on a user interface; and when the user interface responds to the image change message, carrying out pixel fusion on pixel data in the first visual image to generate a second visual image, and carrying out assembly line display on the second visual image on the user interface. The image display smoothness and definition on the user interface can be improved, so that the precision and the use experience of a performance analysis tool are improved.

Description

Technical Field

[0001] The present invention relates to the field of data processing, and in particular to a method and device for displaying a big data linkage instruction pipeline. Background Art

[0002] In the era of big data, as the amount of data continues to increase, people's demand for visualization and analysis of massive data is also increasing. This demand not only requires distributed databases to have extremely high access rate performance, but also puts forward higher requirements on how to display and visualize massive data. Different from traditional data presentation methods, data visualization emphasizes the understanding and cognition of data distribution, increase and decrease trends, size comparison, time and space association, etc. from a macro perspective. Therefore, for the development and optimization of data visualization solutions, it is necessary not only to consider data integrity, but also to take into account the readability and ease of use of data display. In this context, how to effectively display massive data and provide accurate and intuitive data analysis results is extremely important. At the same time, with the advent of the era of big data, data visualization is no longer just about displaying data, but also about extracting valuable information and trends from massive data to assist decision-making and predict the future. This also means that performance analysis tools need to better support multi-dimensional and multi-variable data visualization and interactive analysis.

[0003] However, in the current market, many performance analysis tools, such as Google's Perfetto data visualization tool, are facing many problems. Especially in performance analysis tools with linked zooming function, due to the huge amount of data and the too fast zooming operation, the pixels become thicker and the screen freezes, which has become a common problem in this field. These problems not only bring inconvenience to users, but also affect the accuracy of performance analysis results.

[0004] In view of this, how to overcome the defects of the existing technology and solve the problem that the existing big data performance analysis tools have poor display effects when the data volume is huge and operations such as scaling are performed are problems to be solved in this technical field. Summary of the invention

[0005] In view of the above defects or improvement needs of the prior art, the present invention solves the problem that the existing big data performance analysis tools have poor display effects when the data volume is huge and operations such as scaling are performed.

[0006] The present invention adopts the following technical solution:

[0007] In a first aspect, the present invention provides a method for pipeline display of big data linkage instructions, comprising: obtaining a first visualization image based on data to be displayed, and pipeline displaying the first visualization image on a user interface; when the user interface responds to an image change message, pixel data in the first visualization image is pixel-fused to generate a second visualization image, and pipeline displaying the second visualization image on the user interface.

[0008] Preferably, the obtaining of the first visualized image according to the data to be displayed specifically includes: reading the data to be displayed into a database, performing pipeline visualization according to the data in the database, and obtaining the first visualized image according to the visualization result.

[0009] Preferably, the pixel data in the first visualized image are subjected to pixel fusion to generate the second visualized image, which specifically includes: acquiring first pixel data in the first visualized image, generalizing the first pixel data to obtain smoothed second pixel data; sharpening the second pixel data to obtain third pixel data after image enhancement, and generating the second visualized image based on the third pixel data.

[0010] Preferably, the generalization of the first pixel data to obtain smoothed second pixel data specifically includes: dividing the weight of the first pixel data into spatial weight and grayscale weight, filtering each part of the weight separately, and taking the weighted average of the filtered pixel data as the second pixel data, wherein the spatial weight controls the smoothness of the first pixel data and the grayscale weight controls the edge retention of the first pixel data.

[0011] Preferably, the filtering of each part of the weight separately specifically includes: when the amount of pixel data in a unit area of ​​the user interface is between a first threshold and a second threshold, using a Gaussian filtering method to filter each part of the weight, wherein the second threshold is greater than the first threshold; when the amount of pixel data in a unit area of ​​the user interface is greater than the second threshold, using a mean filtering method to filter each part of the weight.

[0012] Preferably, the filtering of each part of the weight using Gaussian filtering method specifically includes: calculating the weight of each pixel data according to a Gaussian function, calculating the weighted average of the first pixel data according to the weight of the pixel data, and taking the weighted average as the filtering result.

[0013] Preferably, filtering each part of the weight separately also includes: when the pixel data of each pixel in a convolution kernel are equal, the pixel data in the convolution kernel is not filtered.

[0014] Preferably, the sharpening of the second pixel data to obtain the third pixel data after image enhancement specifically includes: filtering the second pixel data to enhance the edges and details in the image; and / or performing edge detection on the second pixel data to increase the details and contours of the image.

[0015] Preferably, the pixel fusion of the pixel data in the first visualized image to generate the second visualized image includes: detecting the image gradient of the pixel data in the second visualized image by an edge detection operator, and when the image gradient does not reach a specified gradient value, adjusting the pixel fusion method and / or parameters, and performing pixel fusion on the data in the first visualized image again.

[0016] On the other hand, the present invention provides a device for displaying a big data linkage instruction pipeline, specifically: including at least one processor and a memory, at least one processor and the memory are connected via a data bus, the memory stores instructions that can be executed by at least one processor, and after the instructions are executed by the processor, they are used to complete the method for displaying a big data linkage instruction pipeline in the first aspect.

[0017] Compared with the prior art, the beneficial effect of the present invention is that when the user interface of the performance analysis tool responds to an image change message, the pixel data in the currently displayed visual image is pixel-fused, and a new visual image that is more suitable for the current display requirements is obtained through pixel fusion for display, so as to improve the smoothness and clarity of the image display on the user interface, thereby improving the accuracy and usage experience of the performance analysis tool. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for use in the embodiments of the present invention. Obviously, the drawings described below are only some embodiments of the present invention, and for ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0019] Figure 1 A flow chart of a method for displaying a big data linkage instruction pipeline provided by an embodiment of the present invention;

[0020] Figure 2 Schematic diagram of the structure of the data visualization pipeline in an embodiment of the present invention;

[0021] Figure 3 A flowchart of the generalization and sharpening process in a certain scene of the method provided by an embodiment of the present invention;

[0022] Figure 4 A flowchart of median filtering used in a certain scenario of the method provided by an embodiment of the present invention;

[0023] Figure 5 A flow chart of a convolution kernel used in a certain scenario of the method provided in an embodiment of the present invention;

[0024] Figure 6 A schematic diagram of the structure of a device for displaying a big data linkage instruction pipeline provided by an embodiment of the present invention;

[0025] The reference numerals are as follows:

[0026] 11: processor; 12: memory. DETAILED DESCRIPTION

[0027] In order to make the purpose, technical solution and advantages of the present invention more clearly understood, the present invention is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not used to limit the present invention.

[0028] The present invention is an architecture of a specific functional system, so the specific embodiments mainly illustrate the functional logical relationship between the various structural modules, and do not limit the specific software and hardware implementation methods.

[0029] In addition, the technical features involved in the various embodiments of the present invention described below can be combined with each other as long as they do not conflict with each other. The present invention will be described in detail below with reference to the accompanying drawings and embodiments.

[0030] At present, there are relatively limited solutions to problems such as freezes or inaccurate display when performance analysis tools are linked to zoom, etc. Therefore, it is necessary to develop new data visualization algorithms and technologies and apply them to performance analysis tools to meet the growing needs of users. Therefore, in the field of performance analysis tools, it is also necessary to achieve a balance between efficient performance and data visualization quality. Therefore, a new solution is provided in this embodiment to improve the accuracy and user experience of performance analysis tools.

[0031] like Figure 1 As shown, the specific steps of the method for displaying the big data linkage instruction pipeline provided by an embodiment of the present invention are as follows.

[0032] Step 101: Acquire a first visualized image according to data to be displayed, and display the first visualized image on a user interface.

[0033] The method provided in this embodiment can be applied to various performance analysis tools. In order to improve display performance, a pipeline display method can be used to improve data processing efficiency and real-time visualization through data processing and data display pipelines. In order to facilitate back-end processing of the data to be displayed, the data to be displayed can be read into the database first, and the data integration analysis can be completed in the database and the back-end server, and the data can be converted into the display attributes such as the size, shape, position, and color of the visualization graphics, and then the visualization display of the items required by the user can be performed on the front end.

[0034] Step 102: When the user interface responds to the image change message, pixel data in the first visual image is pixel-fused to generate a second visual image, and the second visual image is displayed on the user interface.

[0035] When the user interface responds to the image change message, the visual image on the user interface needs to be displayed accordingly according to the change parameters provided by the image change message. In some embodiments, the image change message can be a refresh message caused by a backend data change, or a display change caused by image zooming, panning, selection, annotation, etc. triggered by the front-end user interface.

[0036] In order to avoid the problems of jamming and inaccurate reality caused by changes in image display in the prior art, in the method provided in this embodiment, the new visual image is not directly generated using the change parameters, but the pixel data in the original visual image is first pixel-fused, and then the second visual image is generated according to the fused pixel data. Pixel aggregation is a method of merging adjacent pixels in an image into new pixels according to certain rules. This method can be used to reduce the resolution of the image and reduce the size of the image file. It can also be used for image rendering and display to improve the rendering efficiency and display speed of the image. In the pixel aggregation process, adjacent pixels are merged into a new pixel, and the color and brightness value of the new pixel depend on the color and brightness value of the adjacent pixels. The specific method of pixel aggregation can be selected and adjusted according to different needs and application scenarios. For example, the method and rules of pixel aggregation can be determined according to factors such as the distance between pixels, color similarity, and brightness value. In some graphics rendering and display fields, pixel aggregation is widely used. For example, in performance analysis visualization display, pixel aggregation can merge adjacent performance analysis elements (such as storage units, computing units, instruction sets, tasks, etc.) into a new pixel, thereby reducing rendering complexity and improving the speed and efficiency of performance analysis visualization display. In the field of image processing and compression, pixel aggregation can also be used to reduce the resolution and file size of an image, thereby reducing the cost of storage and transmission. In the method provided in this embodiment, a specific method of pixel fusion can be selected according to the type of change, device performance, data volume, display accuracy, etc., to achieve a balance between display effect and display performance.

[0037] After step 101 and step 102 provided in this embodiment, the problem of non-smooth or inaccurate display of the visualized image in the performance analysis tool when displaying image changes can be solved by pixel fusion.

[0038] In some embodiments, the Figure 2 The structure shown is pipelined. Figure 2 The following is an example of the pipeline display process in a real scene. In actual implementation, you can refer to Figure 2 It can be implemented in the form of Figure 2. Specifically, the data to be visualized is exported as a data file in txt format and stored in a specific directory. For ease of use, the data in the txt data file can be imported into a user database such as mysql through the txt2Database class in the database backend interface. After starting the entry main function Streamer.py, the main window for data visualization will be created, and the login window will be pulled up by the main window. The login window compares the user name and password entered by the user with the data in the user name database. When the user enters the correct account and password, the main window instantiation function will be called to allow the main window to display the visualization image. The user can select the data to be visualized in the menu view of the main window. The main window loads the data into the memory and generates the corresponding visualization image of the data, and displays the visualization image in the data view of the main window. The instruction pipeline is visualized on the timeline, including the start and end time of different instructions at different stages, pc value, id number of the task and process to which it belongs, and other information.

[0039] The data to be displayed is read into a database, pipeline visualization is performed according to the data in the database, and a first visualization image is obtained according to the visualization result. In some embodiments, the specific implementation of each module in the pipeline can be selected as needed, for example, various commonly used databases, data analysis tools, data visualization tools or image processing tools can be used.

[0040] In order to solve display problems such as thickening of pixels, screen freezes, and pixel tearing when the visual image display changes, the method provided in this embodiment adopts pixel fusion to improve the display performance and realistic effect of the visual image display.

[0041] In this embodiment, a method of generalizing first and then sharpening is provided as an example for explanation. In image processing, generalizing first and then sharpening can achieve local contrast enhancement of the image. Its main purpose is to make the details in the image more obvious by increasing the contrast of the image, thereby improving the quality and clarity of the image. It is understandable that the following examples are not specific limitations of the method provided in this embodiment, and can be selected and adjusted according to actual needs and scenarios, or combined with other pixel processing methods without conflict.

[0042] Specifically, the process of generalization followed by sharpening can be divided into two steps: generalization and sharpening. Figure 3 As shown, generalization and sharpening can be performed in the following manner, and pixel data in the first visualization image are pixel-fused to generate a second visualization image.

[0043] Step 201: Acquire first pixel data in a first visualized image, and generalize the first pixel data to obtain smoothed second pixel data.

[0044] Generalization is also called smoothing, which aims to reduce the noise and details in the image and make the image smoother and more uniform. Common generalization methods include Gaussian filtering, mean filtering, median filtering, etc. Generalization can smooth the noise and details in the image by blurring the image while retaining the overall characteristics of the image. Through generalization, the pixelated first visualization image can be restored to a continuous and smooth image as much as possible, weakening the pixel tearing and pixel coarsening caused by the image gradient between adjacent pixels.

[0045] Step 202: sharpen the second pixel data to obtain third pixel data after image enhancement, and generate a second visual image according to the third pixel data.

[0046] Although the generalized image will be smoother, the image edges will be more blurred, reducing the image clarity. Therefore, the generalized pixel data needs to be sharpened. Sharpening is also called enhancement processing, which aims to make the image clearer and more vivid by increasing the contrast and details of the image. Commonly used sharpening methods include Laplace sharpening, Sobel sharpening, Canny edge detection, etc. Sharpening can strengthen the edges and details in the image, thereby achieving the effect of image enhancement. For example, in the performance analysis scenario, the sharpened image can more clearly distinguish each subtle pipeline rectangular module. Through sharpening processing, the generalized blurred image is restored to clarity to meet display requirements and meet user needs.

[0047] After step 201 and step 202 provided in this embodiment, pixel fusion can be achieved through generalization and sharpening, while meeting the requirements of image smoothness and clarity.

[0048] In some implementations, based on the algorithm characteristics of each generalization method and sharpening method, a method applicable to the scene can be selected for pixel fusion. The following provides the algorithm characteristics of some common methods and their applicable scenarios. During specific implementation, the appropriate method can be selected with reference to the following algorithm and scenario description, or other methods that meet the needs of the scene can be used.

[0049] In image processing, commonly used smoothing operators include mean filtering, median filtering and Gaussian filtering, etc. Their main function is to smooth the image by removing noise from the image, and they can also achieve a certain blurring effect.

[0050] 1. Mean filtering.

[0051] Mean filtering is the simplest smoothing algorithm. The principle is to use a sliding window of a specified size to calculate the average value of the pixels in the window and use the average value as the output value of the pixel in the center of the window. Mean filtering is less effective in removing Gaussian noise, but more effective for salt and pepper noise. Its filtering function can be expressed using the following formula:

[0052]

[0053] Among them, g(x,y) represents the pixel value output at the point after mean filtering, m represents the width of the convolution kernel, n represents the height of the convolution kernel, i and j represent the coordinates in this sliding window, s represents the range of this sliding window, x represents the x coordinate of the output point, y represents the y coordinate of the output point, and f(i,j) represents the original pixel with coordinates (i,j) within the range of s.

[0054]

[0055] Among them, K represents the pixel output value of the point, ksize.width represents the width of the convolution kernel, ksize.height represents the height of the convolution kernel, and the matrix represents the coefficient of each pixel multiplication.

[0056] The mean filter has a fast calculation speed. It only needs to add the pixels processed by the convolution kernel and then take the average value. This method is simple to calculate and has a fast image processing speed. It is more commonly used in display scenarios with large data volumes and high real-time requirements, such as big data instruction set pipelines. Preferably, the mean filter with a convolution kernel size of 3*3 and a step size of 1 performs better.

[0057] 2. Median filtering.

[0058] Median filtering is a nonlinear digital signal processing technique used to remove noise from images or signals and preserve signal details as much as possible. Median filtering is a nonlinear filter that, unlike linear filters such as low-pass filters and high-pass filters, does not change the mean or distribution of the signal. Instead, the median filter replaces the value of each pixel with the median of the surrounding pixel values, which helps to remove isolated noise points and suddenly changing signals. Its filter function can be expressed using the following formula:

[0059] g(x,y)=medf{f′(xk,yl)},(k,l∈w),

[0060] Among them, g(x,y) represents the pixel value output at the point, medf represents the function that returns the median, f′ represents the original pixel, x represents the x-coordinate of the output point, k represents the x-coordinate that together with x constitutes the w range, y represents the x-coordinate of the output point, l represents the y-coordinate that together with y constitutes the w range, and w represents the width and height of the filter.

[0061] The core idea of ​​median filtering is to use the median value of the surrounding pixels to replace the value of the central pixel. The number of surrounding pixels is determined by the size of the kernel. A larger kernel can smooth the signal better, but it will cause the loss of image details. Figure 4 As shown, the steps of the median filter are as follows.

[0062] Step 301: Select the size of the kernel. For ease of calculation, the kernel is usually a square.

[0063] Step 302: For each kernel, obtain the values ​​of the surrounding pixels according to the size of the kernel, and sort the values ​​of the surrounding pixels by size.

[0064] Step 303: assign the median value of the surrounding pixel values ​​to the central pixel of the kernel.

[0065] After steps 301 to 303 provided in this embodiment, median filtering can be completed to obtain smoothed pixel data.

[0066] Median filtering is a simple and effective denoising technique that can effectively remove noise and retain the edges and details of the image to a certain extent. However, the processing speed of median filtering is slow, and the pixel values ​​after median filtering always come from the original image. Among all the pixels processed by the convolution kernel at one time, most of the time the pixel values ​​are only two pixels of the left and right pipeline rectangles, which cannot achieve a good smoothing effect.

[0067] 3. Gaussian filtering.

[0068] Gaussian filtering is a smoothing filtering algorithm based on the Gaussian function. The principle is to use a sliding window of a specified size to calculate the weighted average of the pixel values ​​in the window, where the weight of each pixel is calculated by the Gaussian function. Since the center pixel of the Gaussian function has the largest weight, Gaussian filtering is more effective in removing noise and can also retain edge information in the image. Its convolution kernel is as follows: Figure 5 As shown, the filter function can be expressed using the following formula:

[0069]

[0070] Among them, G(x,y) represents the pixel value output by the (x,y) coordinate, and σ is the standard deviation.

[0071] The most important parameter for generating a Gaussian filter template is the standard deviation σ of the Gaussian distribution. The standard deviation represents the degree of discreteness of the data. If σ is small, the central coefficient of the generated template is large, while the surrounding coefficients are small, so the smoothing effect on the image is not very obvious; on the contrary, if σ is large, the coefficients of the generated template are not very different, which is more similar to the mean template, and the smoothing effect on the image is more obvious. Preferably, when the convolution kernel kernelsize is set to 5 and the standard deviation σ is set to 1, a very good smoothing effect can be obtained while taking into account the speed performance of image processing.

[0072] 4. Adaptive filtering.

[0073] In order to meet the needs of more scenarios, multiple generalization algorithms can also be combined to achieve adaptive filtering. Adaptive filtering can automatically adjust the filter parameters and select the most suitable filter according to the pixel characteristics, so as to better remove noise and retain pixel details. Specifically, the weight of the first pixel data is divided into spatial weight and grayscale weight, the spatial weight is used to measure the distance between pixels, and the grayscale weight is used to measure the similarity between pixels. When calculating the pixel value, each part of the weight is filtered separately, and the weighted average of the filtered pixel data is used as the second pixel data, wherein the spatial weight controls the smoothness of the first pixel data, and the grayscale weight controls the edge retention of the first pixel data. The adaptive filter will perform weighted averaging on the pixels according to the spatial weight and grayscale weight, wherein the spatial weight controls the smoothness and the grayscale weight controls the edge retention.

[0074] Furthermore, in a specific implementation, in a scenario such as a big data linkage instruction pipeline display based on pixel aggregation, the amount of data to be processed each time a graphical display is performed will change. When using an adaptive filtering method, different generalization methods can be selected according to different data amounts.

[0075] For example, in a certain scenario, the adaptive filtering method combines mean filtering and Gaussian filtering to implement a bilateral filter to simultaneously maintain signal edges and smooth signals. In order to make full use of the two methods, two data volume thresholds can be set: the first threshold a and the second threshold b. <b。

[0076] (1) When the amount of pixel data in a unit area of ​​the user interface is between a first threshold and a second threshold, a Gaussian filter is used to filter each weight.

[0077] If the amount of data in the unit display frame area is within the range of [a, b], Gaussian filtering is used for processing, the weight of each pixel data is calculated according to the Gaussian function, the weighted average of the first pixel data is calculated according to the weight of the pixel data, and the weighted average is used as the result of filtering to achieve a better smoothing effect. Preferably, Gaussian filtering with a 5*5 Gaussian convolution kernel can be used.

[0078] (2) When the amount of pixel data in a unit area of ​​the user interface is greater than a second threshold, a mean filtering method is used to filter each weight.

[0079] If the amount of data is greater than b, mean filtering is used to increase the smoothing speed, and the real-time performance of smoothing generalization can still be guaranteed in the case of a larger amount of data.

[0080] It can be seen that the above methods can achieve image generalization and have different algorithm characteristics, which can be selected according to the needs of the scene.

[0081] Furthermore, in actual scenes, there are large-scale continuous pixel values ​​such as background colors or data blocks. In order to further improve efficiency and reduce the amount of pixel data processing during generalization, the method provided in this embodiment also adds a pixel area identical judgment mechanism. When the pixel data of each pixel in a convolution kernel are equal, the smoothed pixel is also the original pixel, and the pixel data in the convolution kernel is not filtered. This mechanism can further accelerate the image generalization time, improve image processing performance, and avoid wasting computing resources.

[0082] After generalization is completed, the second pixel data needs to be sharpened to obtain the third pixel data after image enhancement, eliminate the image blur caused by generalization, and meet the clarity requirements of image display.

[0083] (1) Filter the second pixel data to enhance the edges and details in the image.

[0084] By filtering the image, the edges and details in the image can be enhanced, thereby achieving the effect of image sharpening and enhancement. For example, methods such as directional filter sharpening and Laplace sharpening are used.

[0085] (2) Perform edge detection on the second pixel data to increase the details and contours of the image.

[0086] Through edge detection methods, it is possible to increase image contrast, enhance image details and contours, and make the image look clearer and sharper, for example, using Sobel sharpening, Prewitt sharpening, etc.

[0087] It can be seen that the above methods can achieve image sharpening and have different algorithm characteristics, which can be selected according to the needs of the scene. For example: the mean filter has a fast processing speed, but low robustness. Since it ignores the fact that the center point has a greater impact on the pixels of the output point, the effect is relatively general. The median filter is less efficient because it essentially needs to sort each pixel in the filter and return the middle value, but it is better at processing salt and pepper noise. Gaussian filtering takes into account the above two advantages, but is not as fast as mean filtering.

[0088] After completing the pixel fusion of the visualization image, in order to ensure that the obtained second visualization image is clear and accurate, the image gradient of the pixel data in the second visualization image can also be detected by the edge detection operator. When the image gradient does not reach the specified gradient value, the pixel fusion method and / or parameters are adjusted, and the data in the first visualization image is pixel fused again. Finally, the smoothing process is moderate, and the filtering type and parameters that can reduce the image gradient and meet the clarity requirements are obtained. In actual implementation, the appropriate edge detection operator can be selected for detection according to the scene, such as: Canny edge detection operator, Prewitt edge detection operator, Laplacian edge detection operator, LOG edge detection operator, etc.

[0089] The method of displaying the big data linkage instruction pipeline provided in this embodiment first reduces the noise and details in the image, and then increases the contrast and details through pixel fusion methods such as generalization first and then sharpening, so as to make the image clearer and more vivid. This method can be applied to a variety of image processing applications, such as equipment performance analysis, medical image analysis, computer vision, remote sensing image processing, etc.

[0090] Based on the method of displaying the big data linkage instruction pipeline provided in this embodiment, in different specific application scenarios, it can also be supplemented and adjusted according to different usage requirements or actual scenarios. In the case of no conflict, one or more of the following technical solutions can be selected and used in combination with the above technical solutions.

[0091] (1) After obtaining the first visual image, according to the method provided in this embodiment, multiple second visual images of preset proportions are generated according to the first visual image for caching. The preset proportion can be set according to the data type, image display type, user, screen resolution, etc. During the user zooming process, if the zoom ratio deviates greatly from the preset proportion, the second visual image currently required to be displayed is obtained according to the method provided in this embodiment; if the zoom ratio is close to the preset proportion, the cached second visual image with the closest zoom ratio is directly used for display. In a specific implementation, the specific range of the zoom ratio is determined according to actual needs. For example, in a specific scenario, the preset proportions are 50%, 80%, 120%, and 150%, then the second visual images of the above preset proportions are pre-generated for caching. When the user zooms to 49% or 51%, the zoom ratio is automatically adsorbed to 50%, and the cached second visualization image with a zoom ratio of 50% is used for display; when the user zooms to 79% or 81%, the zoom ratio is automatically adsorbed to 80%, and the cached second visualization image with a zoom ratio of 80% is used for display; when the user's zoom ratio is between 51% and 79%, the second visualization image is obtained using the method provided in this embodiment.

[0092] (2) During the user's use, the number of stays and the duration of stays at each zoom ratio that exceeds a certain length of time during the user's historical use are recorded, and the zoom ratio with the largest number of stays or the longest stay duration is used as the preset ratio, and a second visualization image is generated and cached according to the method provided in this embodiment. The preset ratio can be recorded and used according to the data type, image display type, user, screen resolution, etc., and can be updated using various data update strategies. During the user's zooming process, if the zoom ratio deviates greatly from the preset ratio, the second visualization image that needs to be displayed is obtained according to the method provided in this embodiment; if the zoom ratio is close to the preset ratio, the cached second visualization image with the closest zoom ratio is directly used for display. For example: in a specific scenario, the zoom ratios at which the user stays the longest or has the largest number of stays are 105%, 110%, and 115%, and the above zoom ratios are used as the preset ratios.

[0093] (3) During the user's use, if a certain zoom ratio appears for the first time and the user stays at the zoom ratio for more than a certain period of time, the second visualization image generated according to the method provided in this embodiment at the zoom ratio is cached, and when the user zooms to near the zoom ratio again, the cached second visualization image is used for display. During the user's zooming process, if the zoom ratio deviates greatly from the cached zoom ratio, the second visualization image that needs to be displayed is obtained according to the method provided in this embodiment; if the zoom ratio is close to the cached zoom ratio, the cached second visualization image is directly used for display. Furthermore, the zoom ratio that stays for more than a certain period of time can be recorded as a historical zoom ratio, which is used to generate a preset ratio for subsequent use. For example: in a specific scenario, after the user stays at a zoom ratio of 50% for more than a certain period of time, the second visualization image of the zoom ratio of 50% is cached. When the user's zoom ratio reaches 49% to 51% again, the cached second visualization image of the zoom ratio of 50% is used for display, and the zoom ratio of 50% is used as the preset zoom ratio for the next use.

[0094] It can be seen that the above technical solutions can be used alone or simultaneously in combination with the method provided in this embodiment to reduce the amount of calculation when generating the second visualization image and improve display efficiency through image preprocessing and caching.

[0095] In some implementations, it is necessary to perform performance analysis on general-purpose computing on graphics processing units (GPGPU). When performing back-end data processing, the data simulated by the GPGPU model is read into a Mysql database, and then the instruction set pipeline, task status, and utilization of each module are visualized on the front end.

[0096] Due to the huge amount of data, Pyqtgraph is used as the main front-end implementation method, combined with PyQt5 for pipeline display. Pyqtgraph is a high-performance scientific computing and data visualization library based on PyQt and NumPy. It provides a wealth of drawing components and interactive functions, which can be used to draw various types of charts and visualize data. Pyqtgraph supports a variety of chart types, including line graphs, scatter plots, bar graphs, 3D graphs, etc., and also supports drawing custom charts. It is highly customizable, and users can set custom styles, sizes, and colors for drawing elements. In addition, Pyqtgraph also provides interactive functions such as zooming, panning, selecting, and annotating to facilitate users to operate and analyze charts. Another feature of Pyqtgraph is its high performance. Because it uses high-performance computing libraries such as NumPy and Cython at the bottom, it can quickly process large data sets and can update and display data in real time, which is very suitable for fields such as real-time data monitoring and analysis. The PlotItem interface provided by Pyqtgraph has a built-in automatic zoom function, which allows users to easily zoom in and out of the screen without the need for developers to manually write mouse wheel response functions, etc., which is extremely convenient. PlotItem provides a customizable drawing area that allows users to display and interact with data in different ways. PlotItem supports the drawing of multiple curves and areas, as well as axis labels, legends, and other annotations. When using this type of drawing, several steps are generally used: creating a PlotItem object, drawing an image, calling related interfaces for annotations and supplements, writing related interactive functions, and so on. However, in the case of a large amount of data, directly using the plot interface of pyqtgraph still causes freezes and blurs caused by pixel problems. Especially in the display of the GPGPU instruction set pipeline, when the data to be displayed changes too much when pulling or zooming quickly and the amount of data is huge, the phenomenon of pixel tearing is very obvious.

[0097] Therefore, based on the method provided in this embodiment, the img in pyqtgraph can be extracted and image processing can be performed on img. First, various filtering methods are used to generalize the image, with the aim of making the connection between the fine pipeline modules smoother and weakening the pixel tearing caused by the sharp increase in the image gradient. Specifically, the img displayed by the object instantiated by PlotItem is first extracted, and then the image is generalized using an adaptive pixel aggregation method, and then the generalized image is sharpened to increase the contrast of the image, solving the problem of PlotItem display freeze and blur under big data conditions.

[0098] In this scenario, since the image drawn by PlotItem is not disturbed by salt and pepper noise, the disadvantage of mean filtering being extremely effective in removing salt and pepper noise will not be reflected.

[0099] In addition, since the images generated using PlotItem can freely set a fixed background color, resulting in a large number of contiguous background color pixels being the same, the pixel area identity judgment mechanism can also be used to reduce the amount of data processing, improve data processing efficiency, and shorten the response time of image display.

[0100] Based on the method of displaying a big data linkage instruction pipeline provided in this embodiment, this embodiment provides a device for displaying a big data linkage instruction pipeline that can be used to implement the above method, such as Figure 6 , which is a schematic diagram of the device architecture of an embodiment of the present invention. The device shown in the big data linkage instruction pipeline of this embodiment includes one or more processors 11 and a memory 12. Among them, Figure 6 A processor 11 is taken as an example.

[0101] The processor 11 and the memory 12 may be connected via a bus or other means. Figure 6 The example of connecting through bus is taken in the following.

[0102] The memory 12 is a non-volatile computer-readable storage medium as a method for displaying a big data linkage instruction pipeline, and can be used to store non-volatile software programs, non-volatile computer executable programs and modules, such as the method for displaying a big data linkage instruction pipeline in this embodiment. The processor 11 executes various functional applications and data processing of the device for displaying a big data linkage instruction pipeline by running the non-volatile software programs, instructions and modules stored in the memory 12, that is, the method for displaying a big data linkage instruction pipeline in this embodiment is realized.

[0103] The memory 12 may include a high-speed random access memory, and may also include a non-volatile memory, such as at least one disk storage device, a flash memory device, or other non-volatile solid-state storage devices. In some embodiments, the memory 12 may optionally include a memory remotely arranged relative to the processor 11, and these remote memories may be connected to the processor 11 via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0104] The program instructions / modules are stored in the memory 12, and when executed by one or more processors 11, the method of displaying the big data linkage instruction pipeline in the above embodiment is executed, for example, the method described above is executed. Figure 1 , Figure 3 and Figure 4 The steps shown.

[0105] A person skilled in the art may understand that all or part of the steps in the various methods of the embodiments may be completed by instructing related hardware through a program, and the program may be stored in a computer-readable storage medium, and the storage medium may include: a read-only memory (ROM), a random access memory (RAM), a disk or an optical disk, etc.

[0106] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions and improvements 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 displaying a big data linkage instruction pipeline, characterized in that: include: Acquire a first visualized image according to the data to be displayed, and perform pipeline display of the first visualized image on the user interface; When the user interface responds to the image change message, pixel data in the first visual image is pixel-fused to generate a second visual image, and the second visual image is pipeline-displayed on the user interface.

2. The method for displaying a big data linkage instruction pipeline according to claim 1, characterized in that: The acquiring of a first visual image according to the data to be displayed comprises: The data to be displayed are read into a database, pipeline visualization is performed according to the data in the database, and a first visualization image is obtained according to the visualization result.

3. The method for displaying a big data linkage instruction pipeline according to claim 1, characterized in that: The step of performing pixel fusion on the pixel data in the first visual image to generate the second visual image includes: Acquire first pixel data in the first visualized image, and generalize the first pixel data to obtain smoothed second pixel data; The second pixel data is sharpened to obtain third pixel data after image enhancement, and a second visual image is generated according to the third pixel data.

4. The method for displaying a big data linkage instruction pipeline according to claim 3 is characterized in that: The generalizing the first pixel data to obtain smoothed second pixel data includes: The weight of the first pixel data is divided into spatial weight and grayscale weight, each part of the weight is filtered respectively, and the weighted average of the filtered pixel data is used as the second pixel data, wherein the spatial weight controls the smoothness of the first pixel data, and the grayscale weight controls the edge retention of the first pixel data.

5. The method for displaying a big data linkage instruction pipeline according to claim 4 is characterized in that: The filtering of each part of the weights separately comprises: When the amount of pixel data in a unit area of ​​the user interface is between a first threshold and a second threshold, a Gaussian filter is used to filter each weight, wherein the second threshold is greater than the first threshold; When the amount of pixel data in a unit area of ​​the user interface is greater than a second threshold, a mean filtering method is used to filter each weight.

6. The method for displaying a big data linkage instruction pipeline according to claim 5, characterized in that: The method of filtering each part of the weight by using Gaussian filtering includes: The weight of each pixel data is calculated according to the Gaussian function, the weighted average of the first pixel data is calculated according to the weight of the pixel data, and the weighted average is used as the filtering result.

7. The method for displaying a big data linkage instruction pipeline according to claim 4, characterized in that: The filtering of each part of the weights separately also includes: When the pixel data of each pixel in a convolution kernel is equal, the pixel data in the convolution kernel is not filtered.

8. The method for displaying a big data linkage instruction pipeline according to claim 3, characterized in that: The sharpening of the second pixel data to obtain the third pixel data after image enhancement comprises: filtering the second pixel data to enhance edges and details in the image; And / or, edge detection is performed on the second pixel data to increase details and contours of the image.

9. The method for displaying a big data linkage instruction pipeline according to claim 1, characterized in that: The step of performing pixel fusion on the pixel data in the first visual image to generate the second visual image includes: The image gradient of the pixel data in the second visualization image is detected by an edge detection operator. When the image gradient does not reach a specified gradient value, the pixel fusion method and / or parameters are adjusted, and the pixel fusion is performed again on the data in the first visualization image.

10. A device for displaying a big data linkage instruction pipeline, characterized in that: It includes at least one processor and a memory, the at least one processor and the memory are connected via a data bus, the memory stores instructions that can be executed by the at least one processor, and the instructions, after being executed by the processor, are used to complete the method for displaying a big data linkage instruction pipeline as described in any one of claims 1 to 9.

Images