CN114217894B

CN114217894B - Method for realizing radar screen display by adopting Qt

Info

Publication number: CN114217894B
Application number: CN202111505348.2A
Authority: CN
Inventors: 王江枫; 程仕杰; 王明睿; 卢钢; 刘琛; 史亚锋; 李广德
Original assignee: Unit 25 Unit 96901 Chinese Pla; CETC 52 Research Institute
Current assignee: Unit 25 Unit 96901 Chinese Pla; CETC 52 Research Institute
Priority date: 2021-12-10
Filing date: 2021-12-10
Publication date: 2023-09-05
Anticipated expiration: 2041-12-10
Also published as: CN114217894A

Abstract

The application discloses a method for realizing radar screen display by adopting Qt, which stores a point track reported by a radar in a point track data buffer, submits user interaction behavior to a behavior buffer, reads the point track data buffer according to a preset reading period of the point track data buffer, updates basic primitives in a graphic tree, and when triggering user interaction behavior calculation, reads the user interaction behavior from the behavior buffer, performs behavior calculation and updates the basic primitives in the graphic tree by a primitive calculation thread. After the drawing period of the drawing thread is up, the primitive calculation thread reads the graphic tree, converts the basic primitives in the graphic tree into drawing primitives, writes the drawing primitives into a drawing buffer zone, and draws and displays the drawing primitives by the drawing thread. The application increases the primitive calculation thread, reduces the CPU resource occupation, and can effectively prevent the blocking phenomenon of the P display.

Description

Method for realizing radar screen display by adopting Qt

Technical Field

The application belongs to the technical field of Lei Dabing display, and particularly relates to a method for realizing radar screen display by adopting Qt.

Background

The radar display is a terminal device for automatically displaying radar information in real time. The conventional radar image is an original radar video directly output by the receiver or a radar video image subjected to signal processing, which is called one-time display. The computer-processed radar data or the radar image of the integrated video display is called secondary display. The types of radar displays are many, more than ten common picture formats exist, and the types of the radar displays are classified into a first-degree space display, a second-degree space display and a third-degree space display according to the number of displayed coordinates. The two-degree space display adopts brightness modulation, and the basic types of the two-degree space display comprise a polar-coordinate P-type display and a rectangular-coordinate B-type display. The P-type display is also called a planar position display (PPI) or a look-around display, and belongs to radial circular scanning display.

With the development of computer software and hardware, it has been a trend to effectively use GPU for rendering. Currently, the most commonly used technique is over OpenGL. The OpenGL provides support for most graphics card factories due to its high efficiency and independence from the platform. Using OpenGL only transfers the operations that would otherwise be performed on the CPU to the GPU. At present, the scheme of implementing P-graphics using OpenGL does not effectively utilize the characteristics of the OpenGL buffer, so that each change can empty the buffer, and thus the OpenGL finishes a frame of drawing, and more resources are required to be consumed. Qt is a complete set of GUI framework with complete event mechanisms and signal slot mechanisms. And the Qt framework abstracts a drawing system of the bottom layer of the computer, and supports OpenGL are added. In the process of drawing by using OpenGL, the interaction behavior of a user can be effectively captured through a Qt event mechanism and stored in a buffer area.

In the prior art, the P-display diagram developed by OpenGL is used for frequently refreshing the buffer area, so that a large amount of resources are occupied. And the P display is not aimed at the time sequence control of the user interaction behavior, and the calculation of the graphic element is not processed in a multithreading mode, so that the interface is blocked during interaction.

Disclosure of Invention

The application aims to provide a method for realizing radar screen display by adopting Qt, which solves the problems that P-display drawing occupies too much resources and the P-display drawing has a clamping effect in the user interaction process.

In order to achieve the above purpose, the technical scheme of the application is as follows:

a method for realizing radar screen display by adopting Qt is used for drawing a P display diagram of a radar, and the method for realizing radar screen display by adopting Qt comprises the following steps:

storing the point track reported by the radar in a point track data buffer area, and submitting the user interaction behavior to a behavior buffer area;

the graphic element calculation thread reads the point track data buffer according to a preset reading period of the point track data buffer, and updates basic graphic elements in the graphic tree;

when triggering user interaction behavior calculation, a primitive calculation thread reads user interaction behavior from a behavior buffer area, performs behavior calculation and updates basic primitives in a graphic tree;

after the drawing period of the drawing thread is up, the primitive calculation thread reads the graphic tree, converts the basic primitives in the graphic tree into drawing primitives, writes the drawing primitives into a drawing buffer zone, and draws and displays the drawing primitives by the drawing thread.

Further, the primitive calculation thread reads the point track data buffer according to a preset point track data buffer reading period, updates the basic primitive in the graphic tree, and includes:

after reading the point track data buffer, if a newly added point track is found, generating a new basic graphic element, adding the new basic graphic element into a graphic tree, and applying for buffering to the drawing buffer;

after the point track data buffer is read, if the newly added point track is not found, updating the corresponding basic graphic element in the graphic tree according to the point track data read from the point track data buffer.

Further, the triggering the user interaction behavior calculation includes:

the behavior buffer read cycle arrives, or the user interaction behavior is completed.

Further, when triggering the calculation of the user interaction behavior, the primitive calculation thread reads the user interaction behavior from the behavior buffer to perform behavior calculation, and updates the basic primitive in the graphic tree, including:

the basic graphic primitive stores the interactive behavior class in a form of a queue;

when the user interaction behavior calculation is triggered, the basic graphic elements in the graphic tree execute the behavior calculation result according to the stored interaction behavior class.

Further, the method for realizing radar screen display by adopting Qt further comprises:

when the drawing buffer is insufficient, a larger drawing buffer is reapplied.

and after the life cycle of the basic primitive is overtime, the attribution right of the corresponding buffer segment in the drawing buffer zone is emptied, and after the preset time, if a new basic primitive still does not apply for the buffer segment, the buffer segment is thoroughly deleted.

In order to further reduce the utilization rate of a CPU and a GPU, the method for realizing radar screen display by adopting the Qt uses the Qt frame and uses an event mechanism and a signal slot thereof, so that the method can be optimized according to the characteristics of OpenGL on the basis of ensuring the thread safety and the performance, and the purpose can be achieved. OpenGL and Qt are fused, the GPU is effectively used, the frame rate of the P display is improved, and the CPU resource occupation is reduced; on the basis of a Qt frame, the P display diagram is abstracted, and the drawing flow is optimized, so that unnecessary drawing and calculation are avoided; and the interactive behavior of the user is controlled, so that the interactive experience of the user is optimized.

Drawings

FIG. 1 is a flow chart of a method for realizing radar screen display by adopting Qt;

FIG. 2 is a schematic diagram of an embodiment of a primitive computation thread.

Detailed Description

The present application will be described in further detail with reference to the drawings and examples, in order to make the objects, technical solutions and advantages of the present application more apparent. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the application.

The root cause of causing the P display to occupy a large amount of CPU resources and GPU resources and to be blocked during user interaction is that three points are: the calculation of the graph consumes CPU resources; frequent unordered drawing consumes GPU resources; user interaction behavior triggered drawing. The three problems are most basically optimized by abstracting P display graphic primitives and possible user interaction behaviors, controlling external behaviors (such as point track data reported by a radar and user interaction behaviors) and drawing time sequences on the basis of the abstract P display graphic primitives and the possible user interaction behaviors, and finally submitting the data to a buffer zone of OpenGL for drawing.

In one embodiment, as shown in fig. 1, a method for implementing radar screen display by adopting Qt is provided, including:

and S1, storing the point tracks reported by the radar in a point track data buffer area, and submitting the user interaction behaviors to a behavior buffer area.

The form of the P-display primitive encapsulation is ultimately determined by how to submit to OpenGL for rendering at minimal cost. Primitives can be divided into two types according to functions in the drawing process: basic primitives and drawing primitives. The primitive is used for storing the data information of the primitive, such as position, color, etc., while the drawing primitive is used for storing the data of the primitive in the form of OpenGL buffer area, which is convenient for the drawing of OpenGL. Each time a primitive is drawn, the primitive is converted into a drawing primitive, and then the drawing primitive is transferred to OpenGL for drawing.

The external behaviors of the P display comprise radar data input and user interaction behaviors, and the application respectively establishes a point track data buffer area and a behavior buffer area. The radar data input refers to a point track reported by a radar, and the key information of the point track is longitude and latitude height. Considering the limited detection range of the radar, the method can be directly regarded as plane processing, and a similar triangle method can be adopted to convert the longitude and latitude height of the point track into screen coordinates to generate basic graphic primitives.

Taking into consideration that the periodic rule exists in the point track reported by the radar, storing the point track reported by the radar in a mode of establishing a point track data buffer area, and reading data from the point track data buffer area according to a set point track data buffer area reading period to carry out subsequent processing.

Similarly, the user interaction behavior refers to the interaction between the user and the P-display by using an external device such as a mouse and a keyboard, for example, the mouse combination behavior is unpredictable. Unpredictable behavior is manifested in two points: the time of occurrence cannot be predicted and the scale of occurrence cannot be predicted. If the occurrence time cannot be predicted, once the user interaction behavior occurs after a certain frame is drawn, the P display map must be immediately drawn again, so that the interaction effect is reflected; failure to predict the occurrence scale means that the interaction behavior will result in a large number of repeated computations. Thus, a behavior buffer is established for the behavior of interacting with the user. The user interaction behavior is submitted to the behavior buffer area firstly, then after uniform calculation, such as reduction and amplification offset, the behavior calculation result is submitted to the primitive calculation thread for subsequent processing, and the number of primitive calculation times is reduced.

Because the radar data input and the user interaction behavior have different effects on the display needed by the user, the period requirements of processing the point track data buffer area and the behavior buffer area are different, if the real-time performance of the radar data input requirement is not high, the processing of the point track data buffer area once every 30ms is enough, and the user interaction behavior needs to see the effects as soon as possible, and the processing of the behavior buffer area once every 10ms can meet the requirements.

And S2, the graphic element calculation thread reads the point track data buffer according to a preset point track data buffer reading period, and updates the basic graphic element in the graphic tree.

According to the method, on the basis of only one traditional drawing thread (OpenGL drawing thread), one primitive calculation thread is added for the calculation of the primitives. The OpenGL drawing thread is correspondingly provided with a drawing buffer area. The primitive computation thread applies for a storage space during initialization, and manages basic primitives read from the point track data buffer, namely a graphic tree in the storage space in a tree form.

The graphic element calculation thread periodically reads the point track data from the point track data buffer according to the set point track data buffer reading period, and updates the basic graphic elements in the graphic tree according to the following mode:

after reading the point track data buffer, if a newly added point track is found, generating a new basic graphic element, adding the graphic element into a graphic tree, and then applying for buffering to the drawing buffer;

Specifically, if there is a newly added point track, a new basic primitive needs to be generated, then buffering is applied to the drawing buffer area, and after buffering is applied, the drawing buffer area is not operated temporarily. When new point track data is received, the primitive calculation thread applies a section of buffer area to the drawing buffer area of OpenGL, and the drawing buffer area marks the applied section of buffer area with attribution right correspondingly. When the number of point tracks is too large, and the size of the OpenGL drawing buffer is insufficient, a larger buffer is applied.

If the newly added point track is not found after the point track data buffer is read, the original point track data is changed, for example, the position is changed, and the original point track data is required to be updated into the corresponding basic graphic elements in the graphic tree.

And step S3, when the user interaction behavior calculation is triggered, the graphic element calculation thread reads the user interaction behavior from the behavior buffer area, performs behavior calculation and updates the basic graphic element in the graphic tree.

For the behavior buffer, a corresponding behavior buffer reading period is preset as well. The method for triggering the calculation of the user interaction behavior comprises the following steps: the behavior buffer read cycle arrives, or the user interaction behavior is completed. I.e. immediately after the arrival of a behavior buffer read cycle, a behavior calculation is performed. Or, when the user interaction behavior is completed, the behavior calculation can be triggered.

For user interaction behavior (e.g., mouse behavior, keyboard behavior, etc.), all primitives are typically processed in a mouse event or keyboard event triggered by the interaction behavior, and the primitive changes are calculated. But this approach is prone to interface jamming. Therefore, the application encapsulates the user interaction behavior to form the interaction behavior class, and the basic graphic primitive stores the interaction behavior class in a queue form.

When the user interaction behavior calculation is triggered, the basic graphic element in the drawing buffer area executes the behavior calculation result according to the stored interaction behavior class, and the change of the data of the basic graphic element, such as the change of the position, is calculated.

And S4, after the drawing period of the drawing thread is up, the graphic tree is read by the graphic element calculation thread, the basic graphic element is converted into the drawing graphic element, the drawing graphic element is written into the drawing buffer zone, and the drawing thread performs drawing and displaying.

When the basic primitive is calculated, the final step is to draw using the OpenGL drawing thread, which involves conversion of the basic primitive to a drawing primitive. The drawing primitive is essentially a segment of the OpenGL buffer. During P-display initialization, the OpenGL rendering thread initializes a relatively large rendering buffer.

After the drawing period of the drawing thread is reached, the primitive calculation thread reads the basic primitives in the graphic tree, converts the basic primitives into drawing primitives, and writes the drawing primitives into a drawing buffer. And then the drawing thread performs drawing display, and the drawing display is a relatively mature technology in the field and is not described herein.

It should be noted that, for the drawing buffer, the present application further includes some embodiments as follows:

in a specific embodiment, the method for implementing radar screen display by adopting Qt further includes:

when the drawing buffer is insufficient, a larger drawing buffer is reapplied.

Specifically, the application can set a drawing buffer manager, when the request of buffer to the drawing buffer is found, the response is not obtained, or the feedback drawing buffer is insufficient, a request is sent to the drawing buffer manager, and a larger drawing buffer is re-planned to meet the buffer requirement.

For P-display, the basic primitive has a life cycle, and when the basic primitive exceeds the life cycle, the basic primitive should be cleared, and this part of the functions are also executed in the primitive computation thread. For example, when the basic primitive is overtime, the corresponding point track needs to be cleared, the buffer manager receives a request for deleting the point track primitive, and does not delete the segment corresponding to the primitive in the buffer immediately, and also does not sort the buffer immediately, but only clears the attribution right of the segment of the buffer, and after a period of time, if no new primitive still applies for the buffer segment, the buffer is sorted, so that the segment of the buffer segment is deleted thoroughly. Frequent buffer area arrangement will occupy a large amount of CPU resources, and repeated actions in buffer area arrangement process can be avoided by accumulating multiple buffer areas after finishing, so as to reduce CPU resource occupation.

In order to avoid interface jamming, the application starts a primitive calculation thread specially used for processing the data change of the basic primitive. When the data volume is large, a large number of basic graphic element calculations exist in the P display, if all the calculations are concentrated in one thread, interface jam can be caused (a thread for processing a UI interface, if a certain link is not executed, the main thread cannot refresh the interface, and the interface is jammed). Therefore, the application transfers the event triggered by the user interaction behavior to the primitive calculation thread for processing, and can effectively prevent the blocking phenomenon of the P display.

FIG. 2 shows a specific implementation method of a primitive computation thread, after the primitive computation thread is started, a point track data buffer is read, whether newly added point track data exist is judged, if so, a point track basic primitive is generated, the basic primitive is put into a graphic tree, and buffering is applied to an OpenGL buffer.

If there is no newly added point track, some changes to the point track are also updated into the graphics tree. When there is a newly added point track and the original point track data is changed, the newly added point track data also needs to be updated to the basic graphic elements in the graphic tree, and the description is omitted here.

When the reading period of the behavior buffer area arrives, the behavior buffer area is read, and when the behavior exists, the behavior is calculated, the influence of the behavior on the basic graphic primitive is calculated, and the basic graphic primitive in the graphic tree is updated.

Finally, after the drawing period is up, the graphic tree is read, the basic graphic primitive is converted into the drawing graphic primitive, and the drawing graphic primitive is written into the drawing buffer area so as to be drawn and displayed by the OpenGL drawing thread.

The above examples illustrate only a few embodiments of the application, which are described in detail and are not to be construed as limiting the scope of the application. It should be noted that it will be apparent to those skilled in the art that several variations and modifications can be made without departing from the spirit of the application, which are all within the scope of the application. Accordingly, the scope of protection of the present application is to be determined by the appended claims.

Claims

1. The method for realizing radar screen display by adopting Qt is used for drawing a P-display diagram of a radar, and is characterized by comprising the following steps of:

after the drawing period of the drawing thread is up, the primitive calculation thread reads the graphic tree, converts the basic primitives in the graphic tree into drawing primitives, writes the drawing primitives into a drawing buffer zone, and draws and displays the drawing primitives by the drawing thread;

the primitive calculation thread reads the point track data buffer according to a preset point track data buffer reading period, updates the basic primitive in the graphic tree, and comprises the following steps:

after the point track data buffer is read, if the newly added point track is not found, updating the corresponding basic graphic primitive in the graphic tree according to the point track data read from the point track data buffer;

the triggering of the user interaction behavior calculation comprises the following steps:

2. The method for implementing radar screen display by Qt according to claim 1, wherein when triggering user interaction behavior calculation, the primitive calculation thread reads user interaction behavior from the behavior buffer to perform behavior calculation, and updates the basic primitives in the graphic tree, including:

3. The method for implementing radar screen display using Qt according to claim 1, wherein the method for implementing radar screen display using Qt further comprises:

when the drawing buffer is insufficient, a larger drawing buffer is reapplied.

4. The method for implementing radar screen display using Qt according to claim 1, wherein the method for implementing radar screen display using Qt further comprises: