A Two-Stage Planning-Based Autonomous Mission Planning Method for Space-Based Target Observation

Abstract

This invention relates to a two-stage planning method for autonomous mission planning of space-based target observation. The specific steps are as follows: Step 1, First-stage planning: Calculate the visibility duration of all targets, forming an array `visible_time`; based on the length of the visibility duration in `visible_time`, and following the logic of planning targets with shorter visibility durations first, perform a first-stage planning for each target sequentially, and summarize the planning results into the first-stage planning result array `results_first_plan`. This method solves the problem of high computational load in autonomous mission planning for multi-target observation in space by using a rule-based two-stage mission planning approach, and can utilize the limited computing resources on the satellite to complete the observation mission planning problem.

Description

Technical Field

[0001] This invention belongs to the field of satellite mission planning technology, specifically involving an autonomous mission planning method for space-based target observation based on two-stage planning. Background Technology

[0002] This technology addresses the problem of autonomous mission planning for space-based multi-target observation. Current research primarily focuses on space-based surface target observation, with limited research on space observation problems. This field often employs stochastic optimization algorithms such as genetic algorithms and particle swarm optimization to solve this problem. While these methods can achieve good mission planning results, they require significant computing power. However, the onboard computers of some satellites lack the computational capabilities to support these methods, making it difficult to use them for onboard autonomous observation mission planning. Summary of the Invention

[0003] The purpose of this invention is to address the problems existing in the prior art by proposing a two-stage planning method for autonomous mission planning of space-based target observation. The specific steps are as follows:

[0004] Step 1, First Segment Planning: Calculate the visibility duration of all targets, forming an array visible_time; based on the length of the visibility duration in visible_time, perform the first segment planning for each target in turn, following the logic of planning targets with shorter visibility durations first, and summarize the planning results into the first segment planning result array results_first_plan; after completing the first segment planning for each target, check for time conflicts between the selected result window of this planning and all windows in all_wins, and set the flag sign1 of the conflicting window in all_wins to false, looping until all targets have completed one first segment planning;

[0005] Step 2, Second Segment Planning: Combine all windows from the results_first_plan of the first segment planning with all windows from the overall window library all_wins and place them into the window resource array of the second segment planning.

[0006] The `original_wins_last_plan` is used as the source material. For each target, an initial window screening is performed, removing windows that do not meet the screening requirements. Then, on a satellite-by-satellite basis, time conflict resolution and camera rotation constraint resolution are performed on the windows belonging to each satellite in `original_wins_last_plan`. The remaining windows are then incorporated into the second planning result, `results_last_plan`. Finally, satellite working time balancing is performed on the windows in `results_last_plan`, and some windows are trimmed or removed. All remaining windows in `results_last_plan` constitute the planning result.

[0007] Preferably, step 1 consists of the following steps:

[0008] Step 1.1 Sort all windows in all_wins in ascending order of start time; calculate the visible duration of each target in turn, and summarize the results to form a target visible duration array visible_time;

[0009] Step 1.2 Based on the target visibility duration in visible_time, select the target that has not been included in the first segment of planning with the shortest visibility duration;

[0010] Step 1.3 Perform the first phase of planning on the target selected in Step 1.2, and summarize the planning results into the first phase planning result array results_first_plan;

[0011] Step 1.4 Determine if there is a time conflict between the windows in results_first_plan and the windows in the all_wins window library. If a conflict occurs, set sign1 of the conflicting window in the all_wins window library to false.

[0012] If there are still goals that have not been planned in the first paragraph, return to step 1.1.

[0013] Preferably, the specific calculation method for the visibility duration of a single target in step 1.1 is as follows:

[0014] Initialize the variable time, which records the duration the target is visible, to 0;

[0015] Select the first window in the all_wins window library where sign1 is true and the observed target is that target, and record the start time and end time of that window as start_time and end_time, respectively;

[0016] Try to select the next window from the total window library all_wins where sign1 is true and the observed target is the target, and record the start time and end time of the window as start_time and end_time respectively;

[0017] (1) If start_time` ≤ end_time, then let end_time = end_time`;

[0018] (2) If start_time`>end_time, then let time=time+end_time-start_time, start_time=start_time`, end_time=end_time`;

[0019] After traversing all windows in the all_wins window library, let time = time + end_time - start_time; at this point, time is the visible duration of this target.

[0020] Preferably, the specific calculation method for the first segment planning of a single target in step 1.3 is as follows:

[0021] Select all windows in the all_wins library that are observed targets and whose sign1 is true, and put them into the comb_list array of windows to be filtered.

[0022] Start window filtering by comparing all windows in comb_list against the filtering rules. There are three filtering rules. Windows that do not meet the filtering conditions are removed from comb_list until any two windows in comb_list meet filtering rule one and any three windows meet filtering rules two and three.

[0023] (1) Rule 1: Delete windows that overlap completely.

[0024] Let the start time and end time of window 1 be start_time1 and end_time1, respectively, and the start time and end time of window 2 be start_time2 and end_time2, respectively; if Then delete window 2;

[0025] (2) Rule 2: Delete time windows with partial overlap (>80%) and subsequent observation intervals (<30s).

[0026] Let the start and end times of window 1 be start_time1 and end_time1, respectively; the start and end times of window 2 be start_time2 and end_time2, respectively; and the start and end times of window 3 be start_time3 and end_time3, respectively. Delete window 2;

[0027] (3) Rule 3: Subsequent windows do not overlap with the previous window. If the observation interval of a subsequent window is less than 30 seconds, select the subsequent window with a longer observation time.

[0028] Let the start and end times of window 1 be start_time1 and end_time1, respectively; the start and end times of window 2 be start_time2 and end_time2, respectively; and the start and end times of window 3 be start_time3 and end_time3, respectively. Delete window 2;

[0029] To combine partially overlapping time windows in the comb_list into a larger observation arc, the following method is used: Compare all windows in the comb_list pairwise. Let the window with the earlier start time be window 1, and the other be window 2. Their start and end times are start_time1, end_time1, start_time2, and end_time2, respectively. If end_time1 ≥ start_time2, the two windows partially overlap. Then, set end_time1 = end_time2, change the end time of the first window to the end time of the second window, and delete the second window. Repeat this process until no two windows in the comb_list overlap in time.

[0030] Sort the windows in comb_list in ascending order of start time. From the beginning, select the first window whose duration is greater than 5 minutes. If no window in the list lasts longer than 5 minutes, select the window with the longest duration.

[0031] Select all windows belonging to the target that are temporally included in the windows selected in the previous step from the main window library, and the sign1 of these windows must be true; these windows are added to the first planning result array results_first_plan as the result windows of the first planning segment for this target; the method for determining temporal inclusion is as follows:

[0032] Let the start and end times of the windows in the main window library that are being judged be start_time1 and end_time1, and the start and end times of the window selected in the previous step be start_time2 and end_time2. If It is assumed that the windows in the overall window library that are subject to judgment are included in time.

[0033] Preferably, the specific calculation method for determining whether there is a time conflict between the windows in results_first_plan and the windows in the total window library all_wins in step 1.4 is as follows:

[0034] Let start_time1 and end_time1 be the start and end times of the windows to be judged in the main window library, and start_time2 and end_time2 be the start and end times of the windows to be judged in results_first_plan. If start_time2≥end_time1 or start_time1≥end_time2 is not satisfied, then it is considered that there is a time conflict.

[0035] Preferably, step 2 specifically includes the following steps:

[0036] Step 2.1 Set the sign1 of all windows in the first planning result (results_first_plan) to true, indicating that they are windows from the first round of planning results and are old windows. Then, put them all into the second planning window material array (original_wins_last_plan). Set the sign1 of all windows in the total window library (all_wins) to false, indicating that they may be new windows that will soon be added to the planning results. Then, put them all into the second planning window material array (original_wins_last_plan).

[0037] Step 2.2 Perform an initial screening of the windows belonging to each target in original_wins_last_plan, and delete the windows that do not meet the screening requirements;

[0038] Step 2.3 Clear the conflict resolution array conflict_list, select a satellite that has not yet undergone the second phase of planning, and put all windows in original_wins_last_plan that observe satellites that are this satellite into the conflict resolution array conflict_list;

[0039] Step 2.4 Check each pair of new and old windows in conflict_list to see if there is a time conflict. If there is a conflict, trim or delete the window.

[0040] Step 2.5 Check each pair of new windows in conflict_list to see if there is a time conflict. If there is a conflict, trim or delete the window.

[0041] Step 2.6 Check the window with the earliest start time in conflict_list to see if it meets the camera rotation constraint at the start of the scene. If it does not meet the constraint, trim or delete the window.

[0042] Step 2.7 Check each pair of windows in conflict_list to see if they meet the camera rotation constraints. If not, trim or delete the window.

[0043] Step 2.8: Add all windows in conflict_list to the second planning result results_last_plan. If there are still satellites that have not yet been planned for the second phase, return to step 2.3.

[0044] Step 2.9 Perform satellite work duration balancing on all windows in the second planning result results_last_plan. After the balancing is completed, all windows in results_last_plan are the final planning result.

[0045] Preferably, in step 2.4, the specific calculation method for determining whether the new window and the old window have time conflicts, and if so, trimming or deleting the window, is as follows:

[0046] Let the start and end times of the new window be start_time and start_time respectively. new ,end_time new The start and end times of the old window are start_time and start_end_time, respectively. old ,end_time old The shortest window duration is During min There are four types of conflicts, and the ways to resolve them are as follows:

[0047] Conflict Scenario 1:

[0048]

[0049] Solution to Conflict Scenario 1:

[0050] If start_time old -start_time new ≥During min Let end_time new =start_time old Otherwise, delete the new window (new).

[0051] Conflict Scenario 2:

[0052]

[0053] Solution to Conflict Scenario 2:

[0054] If end_time new -end_time old ≥During min Let end_time old =start_time new Otherwise, delete the new window (new).

[0055] Conflict Scenario 3:

[0056]

[0057] Conflict Scenario 3 Solution:

[0058] Delete the new window.

[0059] Conflict Scenario 4:

[0060]

[0061] Conflict Scenario 4 Solution:

[0062] If start_time old -start_time new ≥During min Create a new window named new1 with a start time and an end time of [time values ​​to be filled in]. Its observed satellite number and the observed target number are the same as the new window new, and the new window new1 is saved in conflict_list; if

[0063] end_time new -end_time old ≥During min Create a new window named new2 with a start time and an end time of [time values ​​to be filled in]. The observed satellite number and the observed target number are the same as the new window new, and the new window new2 is saved in conflict_list; after completing the above two judgments, the new window new is deleted.

[0064] Preferably, the specific calculation method for determining whether there is a time conflict between each pair of new windows in step 2.5, and trimming or deleting the window if a conflict is found, is as follows:

[0065] Let the start and end times of the new window 1 be start_time and start_time respectively. new1 ,end_time new1 The start and end times of the new window 2 are start_time and start_end_time respectively. new2 ,end_time new2 The shortest window duration is During min There are two types of conflicts, and the methods for resolving them are as follows:

[0066] Conflict Scenario 1:

[0067]

[0068] Solution to Conflict Scenario 1:

[0069] If start_time new2 -start_time new1 ≥During min Let end_time new1 =start_time new2 Otherwise, delete the new window new1.

[0070] Conflict Scenario 2:

[0071]

[0072] Solution to Conflict Scenario 2:

[0073] Delete the new window (new1).

[0074] Preferably, the specific calculation method for checking whether each window in step 2.6 satisfies the camera rotation constraint in pairs, and trimming or deleting the window if it does not, is as follows:

[0075] Let the start and end times of the window be start_time1 and end_time1, respectively. Let the initial scene time be zero_time. Let rotate_time be the time required for the camera to rotate from the elevation angle at the initial scene time to the elevation angle at the start time of the window. Let the minimum window duration be During. min The conflict and its resolution methods are as follows:

[0076] start_time1-zero_time<rotate_time

[0077] Conflict resolution:

[0078] If end_time1-zero_time≥rotate_time 0→1 +Duringmin Set start_time1 = zero_time + rotate_time, otherwise delete the window.

[0079] Preferably, in step 2.7, the specific calculation method for checking whether the window with the earliest start time satisfies the camera rotation constraint at the start of the scene, and if not, for trimming or deleting the window, is as follows:

[0080] Suppose there are two windows, with the start and end times of the window that starts earlier being start_time1 and end_time1, and the start and end times of the other window being start_time2 and end_time2, respectively. The time required for the camera to rotate from the elevation / azimuth angle at the end time of the window that starts earlier to the elevation / azimuth angle at the start time of the second window is denoted as rotate_time. 1→2 The shortest window duration is During min The conflict and its resolution methods are as follows:

[0081] start_time2-start_time1<rotate_time 1→2

[0082] Conflict resolution:

[0083] If end_time2-end_time1≥rotate_time 1→2 +During min , let start_time2=end_time1+rotate_time 1→2 Otherwise, if start_time2 - start_time1 ≥ rotate_time 1→2 +During min , let end_time1=start_time2-rotate_time 1→2 Otherwise, delete the window with the shorter duration.

[0084] The specific calculation method for satellite operating time balancing in step 2.9 is as follows:

[0085] The working duration of each satellite is calculated based on all windows in results_last_plan by summing the durations of all windows for that satellite.

[0086] If a target that has not yet been selected is chosen during the satellite runtime balancing process, all observed targets in `results_last_plan` are traversed to form a window for that target, and pairwise comparisons are made to determine if there is any time overlap. The method for determining time overlap is as follows:

[0087] In two windows, the start and end times of the window with the earlier start time are start_time1 and end_time1, respectively, and the start and end times of the other window are start_time2 and end_time2, respectively. If start_time2 < end_time1, then there is time overlap.

[0088] For two windows with overlapping time periods, determine whether pruning is necessary. The determination method is as follows:

[0089] Let the satellite observed in the window with the earliest start time be sat1, and its working time be work_time1. Let the satellite observed in the other window be sat2, and its working time be work_time2. The average working time of all satellites is aver_work_time.

[0090] Scenario 1:

[0091]

[0092] Solution 1:

[0093] No operation is performed.

[0094] Scenario 2:

[0095]

[0096] Solution 2:

[0097] end_time1 = start_time2

[0098] Scenario 3:

[0099]

[0100] Solution 3:

[0101] No operation is performed.

[0102] Scenario 4:

[0103]

[0104] Solution 4:

[0105] start_time2 = end_time1

[0106] If the window is trimmed, update the satellite active time and average satellite active time;

[0107] Repeat the above steps until all targets have been selected.

[0108] Beneficial effects

[0109] This method solves the problem of high computational load in autonomous mission planning for multi-target observation in space by using a rule-based two-stage mission planning approach. It can utilize the limited computing resources on the satellite to solve the observation mission planning problem.

[0110] The two-stage planning method first plans a long continuous observation window for each target in the first stage. In the subsequent second stage of expansion planning, the observation window is supplemented and satellite working time is balanced without deleting or modifying the window planned in the first stage. This satisfies the planning objective that each target should have a minimum observation time, as well as the planning objectives that the total observation time of each target should be as long as possible and the working time of each satellite should be as balanced as possible.

[0111] Compared to the conventional task planning method with unified planning, the two-stage planning method of this invention greatly simplifies the planning logic, effectively reduces the amount of planning computation, and satisfies three types of planning objectives with less computation. Attached Figure Description

[0112] Figure 1 This is a Gantt chart (target-time) of the original time window before the tracking task planning in this invention;

[0113] Figure 2 This is a Gantt chart (satellite-time) of the original time window before the tracking task planning in this invention;

[0114] Figure 3 This is a Gantt chart (target-time) of the time window for tracking task planning in this invention;

[0115] Figure 4 This is a Gantt chart (satellite-time) for the time window planning of the tracking task in this invention. Detailed Implementation

[0116] The following combination Figures 1 to 4 This implementation method will be described in detail.

[0117] The present invention provides a two-stage planning method for autonomous mission planning of space-based target observation, the specific steps of which are as follows:

[0118] Step 1, First Segment Planning: Calculate the visibility duration of all targets, forming an array visible_time; based on the length of the visibility duration in visible_time, perform the first segment planning for each target in turn, following the logic of planning targets with shorter visibility durations first, and summarize the planning results into the first segment planning result array results_first_plan; after completing the first segment planning for each target, check for time conflicts between the selected result window of this planning and all windows in all_wins, and set the flag sign1 of the conflicting window in all_wins to false, looping until all targets have completed one first segment planning;

[0119] Step 2, Second Segment Planning: Combine all windows from the results_first_plan of the first segment planning with all windows from the overall window library all_wins and place them into the window resource array of the second segment planning.

[0120] The `original_wins_last_plan` is used as the source material. For each target, an initial window screening is performed, removing windows that do not meet the screening requirements. Then, on a satellite-by-satellite basis, time conflict resolution and camera rotation constraint resolution are performed on the windows belonging to each satellite in `original_wins_last_plan`. The remaining windows are then incorporated into the second planning result, `results_last_plan`. Finally, satellite working time balancing is performed on the windows in `results_last_plan`, and some windows are trimmed or removed. All remaining windows in `results_last_plan` constitute the planning result.

[0121] Step 1 consists of the following steps:

[0122] Step 1.1 Sort all windows in all_wins in ascending order of start time; calculate the visibility duration of each target in turn, and summarize the results to form a target visibility duration array visible_time; the specific calculation method for the visibility duration of a single target in Step 1.1 is as follows:

[0123] Initialize the variable time, which records the duration the target is visible, to 0;

[0124] Select the first window in the all_wins window library where sign1 is true and the observed target is that target, and record the start time and end time of that window as start_time and end_time, respectively;

[0125] Try to select the next window from the total window library all_wins where sign1 is true and the observed target is the target, and record the start time and end time of the window as start_time and end_time respectively;

[0126] (1) If start_time` ≤ end_time, then let end_time = end_time`;

[0127] (2) If start_time`>end_time, then let time=time+end_time-start_time, start_time=start_time`, end_time=end_time`;

[0128] After traversing all windows in the all_wins window library, let time = time + end_time - start_time; at this point, time is the visible duration of this target.

[0129] Step 1.2 Based on the target visibility duration in visible_time, select the target that has not been included in the first segment of planning with the shortest visibility duration;

[0130] Step 1.3 Perform the first phase of planning on the target selected in Step 1.2, and summarize the planning results into the first phase planning result array results_first_plan;

[0131] Step 1.3 The specific calculation method for the first segment of planning for a single objective is as follows:

[0132] Select all windows in the all_wins library that are observed targets and whose sign1 is true, and put them into the comb_list array of windows to be filtered.

[0133] Start window filtering by comparing all windows in comb_list against the filtering rules. There are three filtering rules. Windows that do not meet the filtering conditions are removed from comb_list until any two windows in comb_list meet filtering rule one and any three windows meet filtering rules two and three.

[0134] (1) Rule 1: Delete windows that overlap completely.

[0135] Let the start time and end time of window 1 be start_time1 and end_time1, respectively, and the start time and end time of window 2 be start_time2 and end_time2, respectively; if Then delete window 2;

[0136] (2) Rule 2: Delete time windows with partial overlap (>80%) and subsequent observation intervals (<30s).

[0137] Let the start and end times of window 1 be start_time1 and end_time1, respectively; the start and end times of window 2 be start_time2 and end_time2, respectively; and the start and end times of window 3 be start_time3 and end_time3, respectively. Delete window 2;

[0138] (3) Rule 3: Subsequent windows do not overlap with the previous window. If the observation interval of a subsequent window is less than 30 seconds, select the subsequent window with a longer observation time.

[0139] Let the start and end times of window 1 be start_time1 and end_time1, respectively; the start and end times of window 2 be start_time2 and end_time2, respectively; and the start and end times of window 3 be start_time3 and end_time3, respectively. Delete window 2;

[0140] To combine partially overlapping time windows in the comb_list into a larger observation arc, the following method is used: Compare all windows in the comb_list pairwise. Let the window with the earlier start time be window 1, and the other be window 2. Their start and end times are start_time1, end_time1, start_time2, and end_time2, respectively. If end_time1 ≥ start_time2, the two windows partially overlap. Then, set end_time1 = end_time2, change the end time of the first window to the end time of the second window, and delete the second window. Repeat this process until no two windows in the comb_list overlap in time.

[0141] Sort the windows in comb_list in ascending order of start time. From the beginning, select the first window whose duration is greater than 5 minutes. If no window in the list lasts longer than 5 minutes, select the window with the longest duration.

[0142] Select all windows belonging to the target that are temporally included in the windows selected in the previous step from the main window library, and the sign1 of these windows must be true; these windows are added to the first planning result array results_first_plan as the result windows of the first planning segment for this target; the method for determining temporal inclusion is as follows:

[0143] Let the start and end times of the windows in the main window library that are being judged be start_time1 and end_time1, and the start and end times of the window selected in the previous step be start_time2 and end_time2. If It is assumed that the windows in the overall window library that are subject to judgment are included in time.

[0144] Step 1.4 Determine if there is a time conflict between the windows in results_first_plan and the windows in the all_wins window library. If a conflict occurs, set sign1 of the conflicting window in the all_wins window library to false.

[0145] Step 1.4, determining whether there is a time conflict between the windows in results_first_plan and the windows in the overall window library all_wins, involves the following calculation method:

[0146] Let start_time1 and end_time1 be the start and end times of the windows to be judged in the main window library, and start_time2 and end_time2 be the start and end times of the windows to be judged in results_first_plan. If start_time2≥end_time1 or start_time1≥end_time2 is not satisfied, then it is considered that there is a time conflict.

[0147] If there are still goals that have not been planned in the first paragraph, return to step 1.1.

[0148] Step 2 consists of the following steps:

[0149] Step 2.1 Set the sign1 of all windows in the first planning result (results_first_plan) to true, indicating that they are windows from the first round of planning results and are old windows. Then, put them all into the second planning window material array (original_wins_last_plan). Set the sign1 of all windows in the total window library (all_wins) to false, indicating that they may be new windows that will soon be added to the planning results. Then, put them all into the second planning window material array (original_wins_last_plan).

[0150] Step 2.2 Perform an initial screening of the windows belonging to each target in original_wins_last_plan, and delete the windows that do not meet the screening requirements;

[0151] Step 2.3 Clear the conflict resolution array conflict_list, select a satellite that has not yet undergone the second phase of planning, and put all windows in original_wins_last_plan that observe satellites that are this satellite into the conflict resolution array conflict_list;

[0152] Step 2.4 checks each pair of new and old windows in the conflict_list for time conflicts. If a conflict is found, the window is trimmed or deleted. The specific calculation method for checking each pair of new and old windows for time conflicts in step 2.4 is as follows:

[0153] Let the start and end times of the new window be start_time and start_time respectively. new ,end_time new The start and end times of the old window are start_time and start_end_time, respectively. old ,end_time old The shortest window duration is During min There are four types of conflicts, and the ways to resolve them are as follows:

[0154] Conflict Scenario 1:

[0155]

[0156] Solution to Conflict Scenario 1:

[0157] If start_time old -start_time new ≥During min Let end_time new =start_time old Otherwise, delete the new window (new).

[0158] Conflict Scenario 2:

[0159]

[0160] Solution to Conflict Scenario 2:

[0161] If end_time new -end_time old ≥During min Let end_time old =start_time new Otherwise, delete the new window (new).

[0162] Conflict Scenario 3:

[0163]

[0164] Conflict Scenario 3 Solution:

[0165] Delete the new window.

[0166] Conflict Scenario 4:

[0167]

[0168] Conflict Scenario 4 Solution:

[0169] If start_time old -start_time new ≥During min Create a new window named new1 with a start time and an end time of [time values ​​to be filled in]. Its observed satellite number and the observed target number are the same as the new window new, and the new window new1 is saved in conflict_list; if

[0170] end_time new -end_time old ≥During min Create a new window named new2 with a start time and an end time of [time values ​​to be filled in]. The observed satellite number and the observed target number are the same as the new window new, and the new window new2 is saved in conflict_list; after completing the above two judgments, the new window new is deleted.

[0171] Step 2.5 checks each pair of new windows in the `conflict_list` to see if they contain time conflicts. If a conflict is found, the window is trimmed or deleted. The specific calculation method for checking each pair of new windows in Step 2.5 to see if they contain time conflicts and if so, trimming or deleting the window is as follows:

[0172] Let the start and end times of the new window 1 be start_time and start_time respectively. new1 ,end_time new1 The start and end times of the new window 2 are start_time and start_end_time respectively. new2 ,end_time new2 The shortest window duration is During min There are two types of conflicts, and the methods for resolving them are as follows:

[0173] Conflict Scenario 1:

[0174]

[0175] Solution to Conflict Scenario 1:

[0176] If start_time new2 -start_time new1 ≥During min Let end_time new1 =start_time new2 Otherwise, delete the new window new1.

[0177] Conflict Scenario 2:

[0178]

[0179] Solution to Conflict Scenario 2:

[0180] Delete the new window (new1).

[0181] Step 2.6 checks the window with the earliest start time in `conflict_list` to see if it satisfies the camera rotation constraint at the start of the scene. If not, the window is pruned or deleted. The specific calculation method for checking each pair of windows in Step 2.6 to see if they satisfy the camera rotation constraint, and then pruning or deleting them if not, is as follows:

[0182] Let the start and end times of the window be start_time1 and end_time1, respectively. Let the initial scene time be zero_time. Let rotate_time be the time required for the camera to rotate from the elevation angle at the initial scene time to the elevation angle at the start time of the window. Let the minimum window duration be During. min The conflict and its resolution methods are as follows:

[0183] start_time1-zero_time<rotate_time

[0184] Conflict resolution:

[0185] If end_time1-zero_time≥rotate_time 0→1 +During min Set start_time1 = zero_time + rotate_time, otherwise delete the window.

[0186] Step 2.7 checks each pair of windows in the `conflict_list` to see if they satisfy the camera rotation constraint. If not, the window is trimmed or deleted. The specific calculation method for checking whether the window with the earliest start time in Step 2.7 satisfies the camera rotation constraint at the start of the scene, and if not, is as follows:

[0187] Suppose there are two windows, with the start and end times of the window that starts earlier being start_time1 and end_time1, and the start and end times of the other window being start_time2 and end_time2, respectively. The time required for the camera to rotate from the elevation / azimuth angle at the end time of the window that starts earlier to the elevation / azimuth angle at the start time of the second window is denoted as rotate_time. 1→2 The shortest window duration is During min The conflict and its resolution methods are as follows:

[0188] start_time2-start_time1<rotate_time 1→2

[0189] Conflict resolution:

[0190] If end_time2-end_time1≥rotate_time 1→2 +During min , let start_time2=end_time1+rotate_time 1→2 Otherwise, if start_time2 - start_time1 ≥ rotate_time 1→2 +During min , let end_time1=start_time2-rotate_time 1→2 Otherwise, delete the window with the shorter duration.

[0191] Step 2.8: Add all windows in conflict_list to the second planning result results_last_plan. If there are still satellites that have not yet been planned for the second phase, return to step 2.3.

[0192] Step 2.9 Perform satellite work duration balancing on all windows in the second planning result results_last_plan. After the balancing is completed, all windows in results_last_plan are the final planning result.

[0193] The specific calculation method for satellite duty balance is as follows:

[0194] The working duration of each satellite is calculated based on all windows in results_last_plan by summing the durations of all windows for that satellite.

[0195] If a target that has not yet been selected is chosen during the satellite runtime balancing process, all observed targets in `results_last_plan` are traversed to form a window for that target, and pairwise comparisons are made to determine if there is any time overlap. The method for determining time overlap is as follows:

[0196] In two windows, the start and end times of the window with the earlier start time are start_time1 and end_time1, respectively, and the start and end times of the other window are start_time2 and end_time2, respectively. If start_time2 < end_time1, then there is time overlap.

[0197] For two windows with overlapping time periods, determine whether pruning is necessary. The determination method is as follows:

[0198] Let the satellite observed in the window with the earliest start time be sat1, and its working time be work_time1. Let the satellite observed in the other window be sat2, and its working time be work_time2. The average working time of all satellites is aver_work_time.

[0199] Scenario 1:

[0200]

[0201] Solution 1:

[0202] No operation is performed.

[0203] Scenario 2:

[0204]

[0205] Solution 2:

[0206] end_time1 = start_time2

[0207] Scenario 3:

[0208]

[0209] Solution 3:

[0210] No operation is performed.

[0211] Scenario 4:

[0212]

[0213] Solution 4:

[0214] start_time2 = end_time1

[0215] If the window is trimmed, update the satellite active time and average satellite active time;

[0216] Repeat the above steps until all targets have been selected.

[0217] Example

[0218] In this embodiment, the autonomous mission planning method for space-based target observation based on two-stage planning of the present invention is used for practical operation.

[0219] This example demonstrates a scenario where six satellites are planned to observe five targets over a six-hour period. The CPU used for planning is an i7-12700H. The total planning time was 0.3183929 seconds. In contrast, planning the same scenario using a stochastic optimization algorithm took 22.1556356 seconds, meaning the former's time was only 1.44% of the latter.

[0220] The two-stage planning method of this invention greatly simplifies the planning logic, effectively reduces the amount of computation in planning, and satisfies three types of planning objectives with a small amount of computation.

[0221] The above description of the present invention is only a preferred embodiment of the present invention and is not intended to limit the implementation of the present invention. Those skilled in the art can easily make corresponding modifications or alterations based on the main concept and spirit of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of protection claimed in the claims.

Claims

1. A method for autonomous mission planning of space-based target observation based on two-stage planning, characterized in that, Includes the following steps: Step 1, First Segment Planning: Calculate the visibility duration of all targets and form an array visible_time; based on the length of the visibility duration in visible_time, perform the first segment planning for each target in turn, following the logic of planning targets with shorter visibility durations first, and summarize the planning results into the first segment planning result array results_first_plan; For each target, the first planning segment is completed once. The result window selected in this planning is checked for time conflict with all windows in all_wins. The flag sign1 of the conflicting window in all_wins is set to false. The loop continues until all targets have completed the first planning segment. Step 2, Second Segment Planning: Combine all windows from the results_first_plan of the first segment planning with all windows from the overall window library all_wins and place them into the window resource array of the second segment planning. The `original_wins_last_plan` is used as the source material. For each target, an initial window screening is performed, removing windows that do not meet the screening requirements. Then, on a satellite-by-satellite basis, time conflict resolution and camera rotation constraint resolution are performed on the windows belonging to each satellite in `original_wins_last_plan`. The remaining windows are then incorporated into the second planning result, `results_last_plan`. Finally, satellite working time balancing is performed on the windows in `results_last_plan`, and some windows are trimmed or removed. All remaining windows in `results_last_plan` constitute the planning result.

2. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 1, characterized in that, Step 1 consists of the following steps: Step 1.1 Sort all windows in all_wins in ascending order of start time; calculate the visible duration of each target in turn, and summarize the results to form a target visible duration array visible_time; Step 1.2 Based on the target visibility duration in visible_time, select the target that has not been included in the first segment of planning with the shortest visibility duration; Step 1.3 Perform the first phase of planning on the target selected in Step 1.2, and summarize the planning results into the first phase planning result array results_first_plan; Step 1.4 Determine if there is a time conflict between the windows in results_first_plan and the windows in the all_wins window library. If a conflict occurs, set sign1 of the conflicting window in the all_wins window library to false. If there are still goals that have not been planned in the first paragraph, return to step 1.

1.

3. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 2, characterized in that, Step 1.1 The specific calculation method for the visibility duration of a single target is as follows: Initialize the variable time, which records the duration the target is visible, to 0; Select the first window in the all_wins window library where sign1 is true and the observed target is that target, and record the start time and end time of that window as start_time and end_time, respectively; Try to select the next window from the total window library all_wins where sign1 is true and the observed target is the target, and record the start time and end time of the window as start_time and end_time respectively; (1) If start_time` ≤ end_time, then let end_time = end_time`; (2) If start_time`>end_time, then let time=time+end_time-start_time, start_time=start_time`, end_time=end_time`; After traversing all windows in the all_wins window library, let time = time + end_time - start_time; at this point, time is the visible duration of this target.

4. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 2, characterized in that, Step 1.3 The specific calculation method for the first segment of planning for a single objective is as follows: Select all windows in the all_wins library that are observed targets and whose sign1 is true, and put them into the comb_list array of windows to be filtered. Start window filtering by comparing all windows in comb_list against the filtering rules. There are three filtering rules. Windows that do not meet the filtering conditions are removed from comb_list until any two windows in comb_list meet filtering rule one and any three windows meet filtering rules two and three. (1) Rule 1: Delete windows that overlap completely. Let the start time and end time of window 1 be start_time1 and end_time1, respectively, and the start time and end time of window 2 be start_time2 and end_time2, respectively; if Then delete window 2; (2) Rule 2: Delete time windows with partial overlap and subsequent observation time intervals. Let the start and end times of window 1 be start_time1 and end_time1, respectively; the start and end times of window 2 be start_time2 and end_time2, respectively; and the start and end times of window 3 be start_time3 and end_time3, respectively. Delete window 2; (3) Rule 3: Subsequent windows do not overlap with the previous window. If the observation interval of a subsequent window is less than 30 seconds, select the subsequent window with a longer observation time. Let the start and end times of window 1 be start_time1 and end_time1, respectively; the start and end times of window 2 be start_time2 and end_time2, respectively; and the start and end times of window 3 be start_time3 and end_time3, respectively. Delete window 2; To combine partially overlapping time windows in the comb_list into a larger observation arc, the following method is used: Compare all windows in the comb_list pairwise. Let the window with the earlier start time be window 1, and the other be window 2. Their start and end times are start_time1, end_time1, start_time2, and end_time2, respectively. If end_time1 ≥ start_time2, the two windows partially overlap. Then, set end_time1 = end_time2, change the end time of the first window to the end time of the second window, and delete the second window. Repeat this process until no two windows in the comb_list overlap in time. Sort the windows in comb_list in ascending order of start time. From the beginning, select the first window whose duration is greater than 5 minutes. If no window in the list lasts longer than 5 minutes, select the window with the longest duration. Select all windows belonging to the target that are temporally included in the windows selected in the previous step from the main window library, and the sign1 of these windows must be true; these windows are added to the first planning result array results_first_plan as the result windows of the first planning segment for this target; the method for determining temporal inclusion is as follows: Let the start and end times of the windows in the main window library that are being judged be start_time1 and end_time1, and the start and end times of the window selected in the previous step be start_time2 and end_time2. If It is assumed that the windows in the overall window library that are subject to judgment are included in time.

5. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 2, characterized in that, Step 1.4 The specific calculation method for determining whether there is a time conflict between the windows in results_first_plan and the windows in the total window library all_wins is as follows: Let start_time1 and end_time1 be the start and end times of the windows to be judged in the main window library, and start_time2 and end_time2 be the start and end times of the windows to be judged in results_first_plan. If start_time2≥end_time1 or start_time1≥end_time2 is not satisfied, then it is considered that there is a time conflict.

6. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 1, characterized in that, Step 2 consists of the following steps: Step 2.1 Set the sign1 of all windows in the first planning result (results_first_plan) to true, indicating that they are windows from the first round of planning results and are old windows. Then, put them all into the second planning window material array (original_wins_last_plan). Set the sign1 of all windows in the total window library (all_wins) to false, indicating that they may be new windows that will soon be added to the planning results. Then, put them all into the second planning window material array (original_wins_last_plan). Step 2.2 Perform an initial screening of the windows belonging to each target in original_wins_last_plan, and delete the windows that do not meet the screening requirements; Step 2.3 Clear the conflict resolution array conflict_list, select a satellite that has not yet undergone the second phase of planning, and put all windows in original_wins_last_plan that observe satellites that are this satellite into the conflict resolution array conflict_list; Step 2.4 Check each pair of new and old windows in conflict_list to see if there is a time conflict. If there is a conflict, trim or delete the window. Step 2.5 Check each pair of new windows in conflict_list to see if there is a time conflict. If there is a conflict, trim or delete the window. Step 2.6 Check the window with the earliest start time in conflict_list to see if it meets the camera rotation constraint at the start of the scene. If it does not meet the constraint, trim or delete the window. Step 2.7 Check each pair of windows in conflict_list to see if they meet the camera rotation constraints. If not, trim or delete the windows. Step 2.8: Add all windows in conflict_list to the second planning result results_last_plan. If there are still satellites that have not yet been planned for the second phase, return to step 2.

3. Step 2.9 Perform satellite work duration balancing on all windows in the second planning result results_last_plan. After the balancing is completed, all windows in results_last_plan are the final planning result.

7. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 6, characterized in that, In step 2.4, the new window and the old window are checked pairwise to see if there is a time conflict. If there is a conflict, the window is trimmed or deleted. The specific calculation method is as follows: Let the start and end times of the new window be start_time and start_time respectively. new ,end_time new The start and end times of the old window are start_time and start_end_time, respectively. old ,end_time old The shortest window duration is During min There are four types of conflicts, and the ways to resolve them are as follows: Conflict Scenario 1: Solution to Conflict Scenario 1: If start_time old -start_time new ≥During min Let end_time new =start_time old Otherwise, delete the new window (new); Conflict Scenario 2: Conflict Scenario 2 Solution: If end_time new -end_time old ≥During min Let end_time old =start_time new Otherwise, delete the new window (new); Conflict Scenario 3: Conflict Scenario 3 Solution: Delete a new window (new); Conflict Scenario 4: Conflict Scenario 4 Solution: If start_time old -start_time new ≥During min Create a new window named new1 with a start time and an end time of [time values ​​to be filled in]. Its observed satellite number and the observed target number are the same as the new window new, and the new window new1 is saved in conflict_list; if end_time new -end_time old ≥During min Create a new window named new2 with a start time and an end time of [time values ​​to be filled in]. The observed satellite number and the observed target number are the same as the new window new, and the new window new2 is saved in conflict_list; after completing the above two judgments, the new window new is deleted.

8. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 6, characterized in that, In step 2.5, the specific calculation method for determining whether each new window has a time conflict, and if so, trimming or deleting the window, is as follows: Let the start and end times of the new window 1 be start_time and start_time respectively. new1 ,end_time new1 The start and end times of the new window 2 are start_time and start_end_time respectively. new2 ,end_time new2 The shortest window duration is During min There are two types of conflicts, and the methods for resolving them are as follows: Conflict Scenario 1: Solution to Conflict Scenario 1: If start_time new2 -start_time new1 ≥During min Let end_time new1 =start_time new2 Otherwise, delete the new window new1; Conflict Scenario 2: Conflict Scenario 2 Solution: Delete the new window (new1).

9. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 6, characterized in that, In step 2.6, all windows are checked pairwise to see if they satisfy the camera rotation constraint. If not, the windows are trimmed or deleted. The specific calculation method is as follows: Let the start and end times of the window be start_time1 and end_time1, respectively. Let the initial scene time be zero_time. Let rotate_time be the time required for the camera to rotate from the elevation angle at the initial scene time to the elevation angle at the start time of the window. Let the minimum window duration be During. min The conflict and its resolution methods are as follows: start_time1-zero_time<rotate_time Conflict resolution: If end_time1-zero_time≥rotate_time 0→1 +During min Set start_time1 = zero_time + rotate_time, otherwise delete the window.

10. The autonomous mission planning method for space-based target observation based on two-stage planning according to claim 6, characterized in that, In step 2.7, the window with the earliest start time is checked to see if it meets the camera rotation constraint at the start of the scene. If it does not meet the constraint, the window is trimmed or deleted. The specific calculation method is as follows: Suppose there are two windows, with the start and end times of the window that starts earlier being start_time1 and end_time1, and the start and end times of the other window being start_time2 and end_time2, respectively. The time required for the camera to rotate from the elevation / azimuth angle at the end time of the window that starts earlier to the elevation / azimuth angle at the start time of the second window is denoted as rotate_time. 1→2 The shortest window duration is During min The conflict and its resolution methods are as follows: start_time2-start_time1<rotate_time 1→2 Conflict resolution: If end_time2-end_time1≥rotate_time 1→2 +During min , let start_time2=end_time1+rotate_time 1→2 Otherwise, if start_time2 - start_time1 ≥ rotate_time 1→2 +During min , let end_time1=start_time2-rotate_time 1→2 Otherwise, delete the window with the shorter duration. The specific calculation method for satellite operating time balancing in step 2.9 is as follows: The working duration of each satellite is calculated based on all windows in results_last_plan by summing the durations of all windows for that satellite. If a target that has not yet been selected is chosen during the satellite runtime balancing process, all observed targets in `results_last_plan` are traversed to form a window for that target, and pairwise comparisons are made to determine if there is any time overlap. The method for determining time overlap is as follows: In two windows, the start and end times of the window with the earlier start time are start_time1 and end_time1, respectively, and the start and end times of the other window are start_time2 and end_time2, respectively. If start_time2 < end_time1, then there is time overlap. For two windows with overlapping time periods, determine whether pruning is necessary. The determination method is as follows: Let the satellite observed in the window with the earliest start time be sat1, and its working time be work_time1. Let the satellite observed in the other window be sat2, and its working time be work_time2. The average working time of all satellites is aver_work_time. Scenario 1: Solution 1: No operation is performed. Scenario 2: Solution 2: end_time1 = start_time2 Scenario 3: Solution 3: No operation is performed. Scenario 4: Solution 4: start_time2 = end_time1 If the window is trimmed, update the satellite active time and average satellite active time; Repeat the above steps until all targets have been selected.

Images