Multi-layer radar plot display method and system

Abstract

The invention relates to the technical field of display control platform drive-by-wire software, and provides a multi-layer radar plot display method, which comprises the following steps: S1, creating n transparent layers and adding the transparent layers to a map; s2, the network receives a radar plot message, obtains the distance R and the azimuth A value of all radar plots in the radar plot message, and stores the distance R and the azimuth A value in a set onecesPoints; s3, circularly processing trace points in the onecesPoint set in the thread, setting the brightness of the trace points, and calculating the latitude and longitude of the trace points through a distance and orientation conversion function; s4, in the timing processing slot function, calculating trace point brightness attenuation according to the afterglow level, circularly judging whether trace points exist in each layer, and if the trace points exist in the layers and the number of times of refreshing the layers reaches 10 * bright Value, deleting the layers, and if the number of times of refreshing the layers reaches 10 * bright Value, deleting the corresponding layers, and if the number of times of refreshing the layers reaches 10 * bright Value; and if not, adding 1 to the refreshing times of the layer and attenuating the brightness values of all the plots of the layer by tempValue, finally adding the plots in the allOncePoint MsgList200ms [100] to the corresponding layer, refreshing the map and circularly processing the next layer. The problem that display control software is obviously stuck when the radar plot quantity is large is solved.

Description

Technical Field

[0001] The present invention relates to the technical field of display and control platform wire control software, and in particular to a multi-layer radar point trace display method and system. Background Art

[0002] In modern radar display and control systems, the display and control platform, as the core interface for human-computer interaction, assumes the crucial function of receiving, processing, and displaying radar trace information in real time. With the advancement of radar detection technology and the continuous improvement of target detection capabilities in complex electromagnetic environments, the volume of trace data received by radar systems has increased exponentially. The display and control platform must render and dynamically update this massive amount of trace data in real time to meet the operator's needs for target trajectory tracking and situation analysis. This high-data-volume display scenario poses a significant challenge to the performance of the display and control software, especially when dense traces are displayed. Ensuring smooth and real-time display becomes a pressing technical challenge.

[0003] The radar trace display method of existing display and control platforms usually adopts a mechanism for independent processing of single traces. Specifically, after receiving radar trace data, the software will perform coordinate conversion, graphic mark creation, layer addition and other operations for each trace separately; when the trace needs to be updated or disappears, it will be deleted or the status modified one by one. This method uses a single trace as the minimum processing unit and relies on frequent addition and deletion operations to maintain the display effect. For example, it can achieve an afterglow effect by modifying the brightness value of the trace in real time, or directly delete outdated traces to clear the display. This method can still meet basic display requirements in scenarios with a small number of traces, but when large-scale trace data is input, the complexity of the processing logic and the frequency of operations will increase significantly.

[0004] The above-mentioned traditional methods expose significant flaws when faced with massive amounts of traces: First, the generation and deletion of individual traces results in enormous code overhead, consuming significant computing resources in repetitive underlying operations, resulting in a sharp decline in software efficiency. Second, when the number of traces exceeds the hardware resource capacity, the display and control software will experience significant display lag and refresh delays, seriously affecting the operator's judgment of the target situation. Furthermore, the traditional method uses the logic of independent processing of single points, which makes it difficult to achieve unified management and efficient optimization of trace trajectories, and cannot meet the high-concurrency, real-time display requirements of modern radar systems. These issues have greatly limited the application of existing technologies in complex battlefield environments or high-density target scenarios. A more efficient trace display method is urgently needed to improve the performance of the display and control platform. Summary of the Invention

[0005] In response to the above problems, the purpose of the present invention is to provide a multi-layer radar point trace display method and system to solve the problem that when the number of radar point traces is large, the display and control software of a certain display and control platform will experience obvious jamming. After analysis, the main reason is that the single radar point trace is added or deleted. This processing method has a large code overhead, and insufficient hardware resources cause display jamming when the number of points is large.

[0006] The above-mentioned object of the present invention is achieved through the following technical solutions:

[0007] A multi-layer radar trace display method includes the following steps:

[0008] S1: Create n transparent layers MFeatureGroup named layer_n and add the transparent layers to the map;

[0009] S2: The network receives the radar trace message, obtains the distance R and azimuth A values ​​of all radar traces in the radar trace message, and stores them in a QList containing the trace distance and azimuth. <onecespointsdata>In the collection onecesPoints of type;

[0010] S3: In the thread onecesPointsThread, loop through the points in the collection onecesPoints, set the point brightness afterglowValue, calculate the longitude and latitude of the point through the distance and azimuth conversion function RAEToLonLat H, store the result in the MPoint map point marker variable, and then store it in the layer point array QList<OncePointMsgInfo*> allOncePointMsgList200ms

[100] waits for display processing;

[0011] S4: In the timing processing slot function, the brightness attenuation of the traces is calculated according to the afterglow level brightValue, and the traces are judged in a loop whether there are traces in each layer: if there are traces and the number of layer refreshes reaches 10×brightValue, the layer is deleted; if not, the number of layer refreshes is increased by 1 and the brightness values ​​of all traces in the layer are attenuated by tempValue. Finally, the traces in al lOncePointMsgList200ms

[100] are added to the corresponding layer, the map is refreshed and the next layer is processed in a loop, so that the traces are displayed and deleted in a loop in n layers, forming a trajectory from bright to dark.

[0012] Furthermore, in step S1, n transparent layers MFeatur eGroup named layer_n are created, and the transparent layers are added to the map, specifically:

[0013] S11: In the constructor of the point trace display processing thread onecesPointsThread, n transparent layers are created, and each layer is named using the format of string QString str = "layer_" + QString::number(i+1), where i ranges from 0 to n-1;

[0014] S12: Create an MFeatureGroup layer instance and initialize a transparent layer pPointG roup[i]=new MFeatureGroup(str);

[0015] S13: Add the created transparent layer to the map layer map->addFeatureGroup p(pPointGroup[i]).

[0016] Furthermore, in step S2, the network receives the radar trace message, obtains the distance R and azimuth A values ​​of all radar traces in the radar trace message, and stores them in the QList containing the trace distance and azimuth. <onecespointsdata>The type of collection onecesPoints is as follows:

[0017] S21: In the point trace network receiving thread recvOncePointProcess, a radar point trace message is received and stored in a point trace message structure variable pointRecvMsg, wherein the point trace message structure variable pointRecvMsg stores the complete radar point trace message received from the network;

[0018] S22: parse the point trace message, and add the distance R and direction A values ​​of each point trace to the set QList according to the number of points in each message packet pointRecvMsg.pointNum <onecespointsdata>In oncesPoints, where oncesPointsData is a point track data structure that contains the point track distance float pointDis and the azimuth variable value float pointAz.

[0019] Further, in step S3, the steps of processing the point tracks in the thread oncesPointsThread specifically include:

[0020] Within the while(1) loop of the run function, the data validity is judged through if(onecesPoints.size()>0), a pointer OncePointMsgInfo pointInfoItem is created and memory is allocated, and the afterglowValue is initialized to 255;

[0021] The point track list is cleared by calling pointInfoItem->pointList.clear(), each oncesPointsData element is traversed through for(int i = 0; i < onecesPoints.size(); i++), the pointDis and pointAz values are extracted, and handle.RAEToLonLatH(myLocalLon, myLocalLat, 0, onecesPoints[i].pointDis, onecesPoints[i].pointAz, 0, &mapLon, &mapLat, &mapH) is called to calculate the longitude and latitude of the point track, where myLocalLon and myLocalLat are the longitude and latitude of the map center, and mapLon and mapLat are the output point track coordinates.

[0022] Further, in step S3, it also includes:

[0023] An MPoint object dot is created for each point track, the point track key value ftkey is set in the form of pionts + incrementing serial number, the pen color is Qt::yellow, the width is 2 pixels, and the point track longitude point.lng and the point track latitude point.lat are respectively assigned mapLon and mapLat;

[0024] Add the dot to the point trace list of pointInfoItem through pointInfoItem->pointList.append(dot). After the loop ends, store pointInfoItem in the allOncePointMsgList200ms

[100] array according to the layer index pPointGroupCount, starting from 0 by default. Finally, call onecesPoints.clear() to clear the original data set, where allOncePointMsgList200ms is a QList<OncePointMsgInfo*> array storing the point trace data of n layers.

[0025] Further, in step S4, calculate the point trace brightness attenuation amount tempValue according to the afterglow level brightValue, and loop to judge whether there are point traces in each layer: if there are and the layer refresh count reaches 10×brightValue, delete the layer; if not, increase the layer refresh count by 1 and attenuate the brightness value of all point traces in the layer by tempValue. Specifically:

[0026] Add a 200ms timer pointCount to the oncecesPointsThread thread, and establish a signal-slot connection through connect(pointCount, SIGNAL(timeout()), this, SLOT(slot_pointsDeal200ms()));

[0027] In the slot_pointsDeal200ms() slot function, set the afterglow level brightValue to 1, 3, or 5. When the radar scans a circle in 2000ms and the point trace brightness attenuates to below 55, clear it. Calculate the attenuation amount per 200ms according to the formula tempValue = (255 - 55) * 1.0 / (2000 / 200 * brightValue);

[0028] Traverse the layers through for(int i = 0; i < n; i++), and use oncePointCountInfo[i].index!= 0 to judge whether there are point traces in the layer. The oncePointCountInfo array contains the layer number index of quint16 type and the count of quint8 type;

[0029] If oncePointCountInfo[i].count>=10*brightValue, delete the layer through map->removeFeatureGroup("layer_"+QString::number(i+1)), clear all lOncePointMsgList200ms[i] and rebuild a new layer;

[0030] Otherwise, subtract tempValue from the afterglowValue of all points in the layer and update the brightness through pen.set Color(QColor(255,255,0,afterglowValue)).

[0031] Furthermore, in step S4, the points in allOncePointMsgList200ms

[100] are added to the corresponding layer, the map is refreshed and the next layer is processed in a loop, specifically:

[0032] For the points stored in allOncePointMsgList200ms, add them to the corresponding layer through pPointGroup[pPointGroupCount]->addOverlay(al lOncePointMsgList200ms[pPointGroupCoun t].at(i)->pointList[j]), and call map->fresh() to refresh the map;

[0033] Reset oncePointCountInfo[pPointGroupCount].count to 0 and set oncePointCountInfo[pPointGroupCount].index = pPointGroupCount + 1;

[0034] When pPointGroupCount>=n, it is forced to reset to 0 to implement the circular storage of n layers, so that the points are displayed in the order of layer_1 to layer_n and fade away.

[0035] A multi-layer radar trace display system for executing the multi-layer radar trace display method as described above comprises:

[0036] The layer creation and adding module is used to create n transparent layers MFeatu reGroup named layer_n and add the transparent layers to the map;

[0037] The trace data receiving and parsing module receives radar trace messages from the network, obtains the distance R and azimuth A values ​​of all radar traces in the radar trace message, and stores them in the QL ist containing the trace distance and azimuth. <onecespointsdata>In the collection onecesPoints of type;

[0038] The point coordinate conversion and storage module is used to loop through the points in the onecesPoints collection in the thread onecesPointsThread, set the point brightness afterglowValue, calculate the longitude and latitude of the point through the distance and azimuth conversion function RAEToLonLatH, store the result in the MPoint map point marker variable, and then store it in the layer point array QList<OncePointMsgInfo*> all lOncePointM sgList200ms

[100] wait for display processing;

[0039] The trace display control and layer management module is used to calculate the trace brightness attenuation tempValue according to the afterglow level brightValue in the timing processing slot function, and cyclically determine whether there are traces in each layer: if there are traces and the layer refresh times reach 10×brightValue, the layer is deleted; if not, the layer refresh times are increased by 1 and the brightness values ​​of all traces in the layer are attenuated by tempValue. Finally, the traces in allOncePointMsgList200ms

[100] are added to the corresponding layer, the map is refreshed and the next layer is processed cyclically, so that the traces are cyclically displayed and deleted in n layers, forming a trajectory from bright to dark.

[0040] A computer device includes a memory and one or more processors, wherein the memory stores computer code, and when the computer code is executed by the one or more processors, the one or more processors execute the above method.

[0041] A computer-readable storage medium stores computer code. When the computer code is executed, the above method is performed.

[0042] Compared with the prior art, the present invention has at least one of the following beneficial effects:

[0043] (1) Significantly improve the processing performance of display control software and solve the problem of display freeze: When the traditional method adds and deletes a single point, the code overhead is large, and when the number of points is large, it is easy to cause hardware resources to be insufficient and freeze. The present invention creates n transparent layers (such as n = 100), batch processes points with layers as units, and stores the points in different layers according to time periods to avoid frequent single-point operations. Actual measurements show that when the number of points reaches 5000, the frame rate of the traditional method drops below 5fps, while this solution still maintains a smooth display of more than 30fps, completely solving the freeze problem.

[0044] (2) Processing efficiency is increased by over 300%, and code overhead is significantly reduced: A multi-layer batch processing mechanism is adopted, and the latitude and longitude of points are calculated in batches through the RAEToLonLatH function, avoiding the repeated overhead of single-point coordinate conversion. When the number of layer refreshes reaches a threshold (10×brightValue), batch deletion and reconstruction are performed, replacing the traditional single-point deletion operation. Compared with traditional methods, efficiency is increased by 300% when processing more than 1,000 points, code execution efficiency is improved, and hardware resource usage is reduced.

[0045] (3) Dynamic brightness decay and layer recycling mechanism to optimize visual effects and resource management: The persistence effect of the point trace is flexibly controlled through the persistence level brightValue. The point trace decays according to tempValue = (255-55) / (2000 / 200×brightValue), forming a track from bright to dark. This not only makes it easier for the operator to observe the target movement, but also avoids memory leaks through layer recycling (reset to 0 when pPointGroupCount ≥ n). When the point trace brightness decays below 55, it is automatically cleared, reducing invalid display overhead. BRIEF DESCRIPTION OF THE DRAWINGS

[0046] Figure 1 This is an overall flow chart of the multi-layer radar trace display method of the present invention;

[0047] Figure 2 This is the layer distribution diagram of the present invention;

[0048] Figure 3 This is the display effect diagram of the present invention. The brightValue value is 5, that is, the dot track disappears after 5 circles, and 5 dot tracks corresponding to the target from bright to dark can be displayed;

[0049] Figure 4 This is the overall structure diagram of the multi-layer radar trace display system of the present invention. DETAILED DESCRIPTION

[0050] To make the purpose, technical solutions, and advantages of the embodiments of this application more clear, the technical solutions in the embodiments of this application will be clearly and completely described below in conjunction with the drawings in the embodiments of this application. Obviously, the described embodiments are part of the embodiments of this application, not all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0051] Those skilled in the art will appreciate that, unless otherwise stated, the singular forms "a," "an," "said," and "the" used herein may also include plural forms. It should be further understood that the term "comprising" used in the specification of the present invention refers to the presence of the stated features, integers, steps, operations, elements, and / or components, but does not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0052] The present invention discloses a multi-layer radar dot trace display method and system. Currently, no descriptions or reports of similar inventions have been found, and similar data at home and abroad have not yet been collected. The present invention has been applied in the display and control software of a certain display and control platform. Practice has proved that this method helps to solve the display jamming problem of the display and control software of a certain display and control platform when the dot trace volume is large. Compared with the traditional single dot trace display and deletion method, the present invention adopts a multi-layer display and layer deletion method. The processing method is simpler and more efficient, with less code overhead. After multiple tests and system verification in actual platform environments, the method is reasonably designed and feasible, with the characteristics of easy transplantation, strong versatility and high maintainability. It can be widely used in the development of similar projects and can greatly shorten the software development cycle and reliability of similar functional modules.

[0053] The following is described by specific examples:

[0054] First embodiment

[0055] like Figure 1 As shown, this embodiment provides a multi-layer radar trace display method, including the following steps:

[0056] S1: Create n transparent layer MFeatureGroups named layer_n and add the transparent layers to the map.

[0057] like Figure 2 As shown, in the constructor of the point trace display processing thread onecesPointsThread, 100 transparent layers are created, QString str = "layer_" + QString::number(i+1), pPointGroup[i] = newMFeatureGroup(str), and the layer is added to the map map->ad dFeatureGroup(pPointGroup[i]).

[0058] S2: The network receives the radar trace message, obtains the distance R and azimuth A values ​​of all radar traces in the radar trace message, and stores them in a QList containing the trace distance and azimuth. <onecespointsdata>A collection of type onecesPoints.

[0059] In the point trace network receiving thread recvOncePointProcess, the radar point trace message is received and stored in the point trace message structure variable pointRecvMsg. The point trace message is parsed and the distance and azimuth values ​​of each point trace are appended to QList according to the number of points in each packet pointRecvMsg.pointNum. <onecespointsdata>In onecesPoints, onecesPointsData is a point data structure, which includes the point distance floatpointDis and the orientation variable value float pointAz.

[0060] S3: In the thread onecesPointsThread, loop through the points in the collection onecesPoints, set the point brightness afterglowValue, calculate the longitude and latitude of the point through the distance and azimuth conversion function RAEToLonLat H, store the result in the MPoint map point marker variable, and then store it in the layer point array QList<OncePointMsgInfo*> Waiting for display processing in allOncePointMsgList200ms

[100] .

[0061] In the timing processing slot function, first calculate the point trace brightness attenuation tempValue according to the afterglow level brightValue, and then delete the layer. First, loop to determine whether there are points on each layer. If so, determine the number of refreshes of the layer. If the value reaches 10*brightValue, the layer needs to be deleted, so that all the points on the layer disappear. If the value does not reach 10*brightVal ue, the number of layer refreshes is increased by 1, and the brightness value of all the points on the layer is attenuated by the tempValue value. Finally, the points in allOncePointMsgList200ms are displayed, and all map point marks MPoint are added to the corresponding layer MFeatureGroup. The map is refreshed map->fresh(), the layer count count is set to 0, the layer number index is set to pPointGroupCount+1, pPoin tGroupCount is the current layer subscript, and pPointGroupCount++ enters the next layer processing, so that multiple layers are cyclically stored in the point trace display.

[0062] Specifically, in this embodiment, the following steps are included: In the run function of the onecesPointsThread thread, the while(1) loop judges if(onecesPoints.size()>0). OncePointMsgInfo* pointInfoItem = new OncePointMsgInfo, where the OncePointMsgInfo structure contains member variables float afterglowValue and QList<MPoint*> pointList. The afterglowValue is the grayscale value used to set the brightness of the point trace, which is the A value of RGBA, and its value range is 0 - 255. MPoint is the map point marker. pointInfoItem->pointList.clear(). In the for loop of for(int i = 0; i < onecesPoints.size(); i++), handle.RAET oLonLatH(myLocalLon, myLocalLat, 0, onecesPoints[i].pointDis, onecesPoints[i].pointAz, 0, &mapLon, &mapLat, &mapH) is called. The map longitude and latitude values mapLon and mapLat of the point trace can be calculated according to the map center longitude and latitude myLocalLon and myLocalLat, and the point trace distance and azimuth values onecesPoints[i].pointDis and onecesPoints[i].pointAz. Then MPoint* dot = new MPoint(), the point trace key value is set, dot->ftkey = "pionts" + QString::number(m_key++), dot->pen.setColor(Qt::yellow) sets the point trace color to yellow, dot->pen.setWidth(2) sets the point trace size, dot->point.lng = mapLon sets the point trace longitude, dot->point.lat = mapLat sets the point trace latitude, pointInfoItem->pointList.append(dot), and the set single point trace is appended to pointInfoItem. After the for loop, allOncePointMsgList200ms[pPointGroupCount].append(pointInfoItem), onecesPoints.clear(), where all lOncePointMsgList200ms is declared as QList<OncePointMsgInfo*> al lOncePointMsgList200ms

[100] is used to store point data of up to 100 layers. pPointGroupCount is the layer index. The default value is 0, which means that data is stored starting from layer 1. The above steps complete the processing of onecesPoints point data.

[0063] S4: In the timing processing slot function, the brightness attenuation of the traces is calculated according to the afterglow level brightValue, and the traces are judged in a loop whether there are traces in each layer: if there are traces and the number of layer refreshes reaches 10×brightValue, the layer is deleted; if not, the number of layer refreshes is increased by 1 and the brightness values ​​of all traces in the layer are attenuated by tempValue. Finally, the traces in al lOncePointMsgList200ms

[100] are added to the corresponding layer, the map is refreshed and the next layer is processed in a loop, so that the traces are displayed and deleted in a loop in n layers, forming a trajectory from bright to dark.

[0064] In the onecesPointsThread thread, add a 200ms timer pointCount, signal-slot connection connect(pointCount,SIGNAL(timeout()),this,SLOT(slot_pointsD eal 200ms())), where slot_pointsDeal 200ms() is the dot trace display processing function. In the slot function slot_pointsDeal 200ms(), the afterglow level brightValue unit is circle, with values ​​of 1, 3, and 5, that is, the radar scans a certain number of circles before the trace disappears. If the radar scan time is 2000ms, the trace brightness decays to 55 when the trace is cleared. Because the display is not obvious when the brightness is less than 55, it is not conducive to the operator's observation. The trace brightness decay amount per 200ms can be calculated as float tempValue = (255-55)*1.0 / (2000 / 200*brightValue), and then in for(int i=0;i<100;i++), judge the layer number if(oncePointCountInfo[i].index!=0), so as to judge whether there are points on the layer, where oncePointCountInfo is the parameter value corresponding to 100 layers, including the layer number quint16 index, the layer 200ms count quint8 count, oncePointCou ntInfo[i].count++,if(oncePointCountInfo[i].count>=(10*brightValu e)), that is, the layer refresh has reached 10*brightValue times, and all points on the layer need to be cleared, QString str="layer_"+QString::number(i+1), map->removeFeatureGroup(str), the corresponding layer data is cleared allOncePointMsgList200ms[i].clear(), and a new layer pPointGroup[i]=new MFeatureGroup(str), map->addFeatureGroup tureGroup(pPointGroup[i]), if oncePointCountInfo[i].count value does not reach 10*brightValue, then the brightness value of all points in this layer is attenuated by tempValue, afterglowValue=afterglowValue-tempValue, pen.Finally, process the points stored in allOncePointMsgList200ms and add them to the layer: pPointGroup[pPointGroupCount]->addOverlay(allOncePointMsgList200ms[pPointGroup pCount].at(i)->pointList[j]). Refresh the map: map->fresh(). Clear the layer count: oncePointCountInfo[pPointGroupCount].count = 0. Set the layer number: oncePointCountInfo[pPointGroupCount].index = pPointGroupCount+1. Enter the next layer: pPointGroupCount++. Circularly store points in 100 layers: if(pPointGroupCount>=100){pPointGroupCount=0;}. The final display effect is as follows. Figure 3 shown.

[0065] The final display effect is that layer_1 stores all radar traces received in the first time period. In the next time period, all received radar traces are stored in layer_2. At this time, the brightness of all traces in layer_1 is attenuated by tempValue. And so on. When the layer is refreshed 10*brightValue times, layer_1 is deleted, all traces in layer_1 disappear, and a new layer_1 is created. In short, at a fixed time period, all radar traces received and stored in allOncePointMsgList for 200ms are cyclically displayed and deleted in n layers, so that the corresponding target's trajectory from bright to dark is brightValue.

[0066] Second embodiment

[0067] like Figure 4 As shown, this embodiment provides a multi-layer radar trace display system for executing the multi-layer radar trace display method in the first embodiment, comprising:

[0068] The layer creation and adding module 1 is used to create n transparent layers MFea tureGroup named layer_n and add the transparent layers to the map.

[0069] The trace data receiving and parsing module 2 receives the radar trace message from the network, obtains the distance R and azimuth A values ​​of all radar traces in the radar trace message, and stores them in the QList containing the trace distance and azimuth. <onecespointsdata>A collection of type onecesPoints.

[0070] Point coordinate conversion and storage module 3 is used to loop through the points in the collection onecesPoints in the thread onecesPointsThread, set the point brightness afterglowValue, calculate the longitude and latitude of the point through the distance and azimuth conversion function RAEToLonLatH, store the result in the MPoint map point marker variable, and then store it in the layer point array QList<OncePointMsgInfo*> all lOncePoint tMsgList200ms

[100] waiting for display processing.

[0071] The trace display control and layer management module 4 is used to calculate the trace brightness attenuation tempValue according to the afterglow level brightValue in the timing processing slot function, and cyclically determine whether there are traces in each layer: if there are traces and the layer refresh times reach 10×brightValue, the layer is deleted; if not, the layer refresh times are increased by 1 and the brightness values ​​of all traces in the layer are attenuated by tempValue, and finally the traces in allOncePointMsgList200ms

[100] are added to the corresponding layer, the map is refreshed and the next layer is processed cyclically, so that the traces are cyclically displayed and deleted in n layers, forming a trajectory from bright to dark.

[0072] A computer-readable storage medium stores computer code. When the computer code is executed, the above-described method is performed. A person skilled in the art will appreciate that all or part of the steps in the various methods of the above-described embodiments can be performed by a program instructing related hardware. The program can be stored in a computer-readable storage medium. The storage medium may include a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk.

[0073] The above description is merely a preferred embodiment of the present invention. The scope of protection of the present invention is not limited to the above embodiment. All technical solutions based on the concept of the present invention are within the scope of protection of the present invention. It should be noted that for those skilled in the art, various improvements and modifications that do not depart from the principles of the present invention should also be considered within the scope of protection of the present invention.

[0074] The technical features of the above-mentioned embodiments can be combined arbitrarily. In order to make the description concise, not all possible combinations of the technical features in the above-mentioned embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0075] It should be noted that the above embodiments can be freely combined as needed. The above description is only a preferred embodiment of the present invention. It should be pointed out that those skilled in the art can make several improvements and modifications without departing from the principles of the present invention, and such improvements and modifications should also be considered within the scope of protection of the present invention.< / onecespointsdata> < / onecespointsdata> < / onecespointsdata> < / onecespointsdata> < / onecespointsdata> < / onecespointsdata> < / onecespointsdata>

Claims

1. A multi-layer radar trace display method, characterized in that: The following steps are involved: S1: Create n transparent layers MFeatureGroup named layer_n and add the transparent layers to the map; S2: The network receives the radar trace message, obtains the distance R and azimuth A values ​​of all radar traces in the radar trace message, and stores them in a QList containing the trace distance and azimuth. <onecespointsdata> In the collection onecesPoints of type;< / onecespointsdata> S3: In the thread onecesPointsThread, loop through the points in the collection onecesPoints, set the point brightness afterglowValue, calculate the longitude and latitude of the point through the distance and azimuth conversion function RAEToLonLat H, store the result in the MPoint map point marker variable, and then store it in the layer point array QList<OncePointMsgInfo*> allOncePointMsgList200ms[100] waits for display processing; S4: In the timing processing slot function, the brightness attenuation of the traces is calculated according to the afterglow level brightValue, and the traces are judged in a loop whether there are traces in each layer: if there are traces and the number of layer refreshes reaches 10×brightValue, the layer is deleted; if not, the number of layer refreshes is increased by 1 and the brightness values ​​of all traces in the layer are attenuated by tempValue. Finally, the traces in allOncePointMsgList200ms[100] are added to the corresponding layer, the map is refreshed and the next layer is processed in a loop, so that the traces are displayed and deleted in a loop in n layers, forming a trajectory from bright to dark.

2. The multi-layer radar trace display method according to claim 1, characterized in that: In step S1, n transparent layers MFeatureGroup named layer_n are created and added to the map, specifically: S11: In the constructor of the point trace display processing thread onecesPointsThread, n transparent layers are created, and each layer is named using the format of string QString str = "layer_" + QString::number(i+1), where i ranges from 0 to n-1; S12: Create an MFeatureGroup layer instance and initialize a transparent layer pPointG roup[i]=newMFeatureGroup(str); S13: Add the created transparent layer to the map layer map->addFeatureGroup p(pPointGroup[i]).

3. The multi-layer radar trace display method according to claim 1, characterized in that: In step S2, the network receives the radar trace message, obtains the distance R and azimuth A values ​​of all radar traces in the radar trace message, and stores them in the QList containing the trace distance and azimuth. <onecespointsdata> The type of collection onecesPoints is as follows:< / onecespointsdata> S21: In the point trace network receiving thread recvOncePointProcess, a radar point trace message is received and stored in a point trace message structure variable pointRecvMsg, wherein the point trace message structure variable pointRecvMsg stores the complete radar point trace message received from the network; S22: parse the point trace message, and add the distance R and direction A values ​​of each point trace to the set QList according to the number of points in each packet pointRecvMsg.pointNum <onecespointsdata>In onecesPoints, where onecesPointsData is a point track data structure that contains the point track distance float pointDis and the azimuth variable value float pointAz. < / onecespointsdata> 4. The multi-layer radar trace display method according to claim 1, characterized in that: In step S3, the steps of processing the point tracks in the thread onecesPointsThread specifically include: Inside the while(1) loop of the run function, if(onecesPoints.size()>0) is used to judge the data validity. A pointer pointInfoItem of OncePointMsgInfo is created and memory is allocated. The afterglowValue is initialized to 255. Call pointInfoItem->pointList.clear() to clear the point track list. Traverse each onecesPointsData element through for(int i = 0; i < onecesPoints.size(); i++), extract the pointDis and pointAz values, and call handle.RAEToLonLatH(myLocalLon, myLocalLat, 0, onecesPoints[i].pointDis, onecesPoints[i].pointAz, 0, &mapLon, &mapLat, &mapH) to calculate the longitude and latitude of the point track, where myLocalLon and myLocalLat are the longitude and latitude of the map center, and mapLon and mapLat are the output point track coordinates.

5. The multi-layer radar trace display method according to claim 4, characterized in that: In step S3, it also includes: Create an MPoint object dot for each point track, set the point track key value ftkey in the form of pionts + incrementing serial number, the pen color is Qt::yellow, the width is 2 pixels, and the point track longitude point.lng and the point track latitude point.lat are respectively assigned mapLon and mapLat. Add dot to the point track list of pointInfoItem through pointInfoItem->pointList.append(dot). After the loop ends, store pointInfoItem in the allOncePointMsgList200ms[100] array according to the layer index pPointGroupCount, starting from 0 by default. Finally, call onecesPoints.clear() to clear the original data set, where allOncePointMsgList200ms is a QList<OncePointMsgInfo*> array that stores the point track data of n layers.

6. The multi-layer radar trace display method according to claim 1, characterized in that: In step S4, calculate the trace brightness attenuation amount tempValue according to the afterglow level brightValue, and loop to determine whether there are traces in each layer: if there are traces and the layer refresh count reaches 10×brightValue, delete the layer; if not, increment the layer refresh count by 1 and attenuate the brightness values of all traces in the layer by tempValue. Specifically: Add a 200ms timer pointCount to the oncesPointsThread thread, and establish a signal-slot connection through connect(pointCount, SIGNAL(timeout()), this, SLOT(slot_pointsDeal 200ms())). In the slot_pointsDeal 200ms() slot function, set the afterglow level brightValue to 1, 3, or 5. When the radar scans a full circle in 2000ms and the trace brightness decays to below 55, clear it. Calculate the attenuation amount per 200ms according to the formula tempValue = (255 - 55) * 1.0 / (2000 / 200 * brightValue). Traverse the layers through for(int i = 0; i < n; i++), and use oncePointCountInfo[i].index!= 0 to determine whether there are traces in the layer. The oncePointCountInfo array contains the layer number index of quint16 type and the count of quint8 type. If oncePointCountInfo[i].count >= 10 * brightValue, delete the layer through map->removeFeatureGroup("layer_" + QString::number(i + 1)), clear allOncePointMsgList200ms[i], and rebuild a new layer. Otherwise, subtract tempValue from the afterglowValue of all traces in the layer, and update the brightness through pen.setColor(QColor(255, 255, 0, afterglowValue)).

7. The multi-layer radar trace display method according to claim 6, characterized in that: In step S4, add the traces in allOncePointMsgList200ms[100] to the corresponding layer, refresh the map, and loop to process the next layer. Specifically: For the points stored in allOncePointMsgList200ms, add them to the corresponding layer through pPointGroup[pPointGroupCount]->addOverlay(allOncePointMsgList200ms[pPointGroupCoun t].at(i)->pointList[j]), and call map->fresh() to refresh the map; Reset oncePointCountInfo[pPointGroupCount].count to 0 and set oncePointCountInfo[pPointGroupCount].index = pPointGroupCount + 1; When pPointGroupCount>=n, it is forced to reset to 0 to implement the circular storage of n layers, so that the points are displayed in the order of layer_1 to layer_n and fade away.

8. A multi-layer radar trace display system for executing the multi-layer radar trace display method according to any one of claims 1 to 7, characterized in that: include: The layer creation and adding module is used to create n transparent layers MFeatu reGroup named layer_n and add the transparent layers to the map; The trace data receiving and parsing module receives radar trace messages from the network, obtains the distance R and azimuth A values ​​of all radar traces in the radar trace message, and stores them in the QL ist containing the trace distance and azimuth. <onecespointsdata> In the collection onecesPoints of type;< / onecespointsdata> The point coordinate conversion and storage module is used to loop through the points in the onecesPoints collection in the thread onecesPointsThread, set the point brightness afterglowValue, calculate the longitude and latitude of the point through the distance and azimuth conversion function RAEToLonLatH, store the result in the MPoint map point marker variable, and then store it in the layer point array QList<OncePointMsgInfo*> all lOncePointM sgList200ms[100] wait for display processing; The trace display control and layer management module is used to calculate the trace brightness attenuation tempValue according to the afterglow level brightValue in the timing processing slot function, and cyclically determine whether there are traces in each layer: if there are traces and the layer refresh times reach 10×brightValue, the layer is deleted; if not, the layer refresh times are increased by 1 and the brightness values ​​of all traces in the layer are attenuated by tempValue. Finally, the traces in allOncePointMsgList200ms[100] are added to the corresponding layer, the map is refreshed and the next layer is processed cyclically, so that the traces are cyclically displayed and deleted in n layers, forming a trajectory from bright to dark.

9. A computer device comprising a memory and one or more processors, wherein the memory stores computer code, and when the computer code is executed by the one or more processors, the one or more processors are caused to perform the method according to any one of claims 1 to 7. 10 . A computer-readable storage medium storing computer code, wherein when the computer code is executed, the method according to claim 1 is performed.

Images