Star target extraction FPGA parallel computing method suitable for star sensor

Abstract

The invention discloses a star target extraction FPGA parallel computing method suitable for a star sensor, and relates to the field of photoelectric imaging, and the method comprises the following steps: firstly, preprocessing a star map through high-pass filtering and Robinson Guard filtering; the method comprises the following steps of: realizing row delay of pixel data by utilizing FIFO (First In First Out) in an FPGA (Field Programmable Gate Array), improving a target clustering mode from row-by-row scanning to column-by-column scanning propulsion, and allocating a BRAM (Border Random Access Memory) and a DRAM (Dynamic Random Access Memory) to construct a clustering data storage Then, carrying out connectivity search on inter-column clustering data by adopting a heap structure, and synchronously calculating characteristic parameters such as a centroid coordinate, a gray scale and the like of a target in a clustering process; and finally, according to the morphological features of the targets, removing false targets, and sorting and outputting the extraction results according to gray levels. According to the invention, parallel computing of image processing and target extraction is realized by using fewer FPGA resources, and target information can be output while image acquisition is completed, so that the bottleneck of computing speed caused by large-size star map processing is effectively solved, and the output frame rate of the star sensor is improved.

Description

Technical Field

[0001] This invention relates to the field of photoelectric imaging technology, and more specifically, to an FPGA parallel computing method for star target extraction suitable for star sensors. Background Technology

[0002] A star sensor is a fixed-focus lens camera, with the photoelectric sensor mounted on the focal plane of the lens. Starlight (parallel light) is focused onto the photoelectric sensor after passing through the lens, where photoelectric conversion is completed to form a digital star map. Stars appear as small bright spots at different positions in the image.

[0003] The star sensor extracts the position coordinates of the star image in the sensor and the position vector in the star sensor coordinate system by extracting the star target; it identifies the star and calculates the current attitude of the star sensor based on the position vector of the star point in the star sensor coordinate system and the position vector in the inertial frame.

[0004] Star sensor images are typically megapixel-level (1 million to 4 million) grayscale images, with each pixel grayscale value represented by 10 to 14 bits. The data size of a single image can reach 2 MByte to 8 MByte. Image preprocessing and star target extraction require a huge amount of computation, especially when using image segmentation and image clustering methods to extract star targets. The computational speed is the main bottleneck for improving the output frame rate of star sensors.

[0005] There are two commonly used image clustering methods: line-by-line scanning fast clustering and seeded four (eight)-neighborhood clustering. These two methods are generally performed serially on CPUs or DSP+memory chips that can dynamically allocate large amounts of storage space, resulting in severely insufficient timeliness. To improve clustering speed, the clustering algorithm needs to be ported to an FPGA for parallel processing.

[0006] The image line-by-line scanning fast clustering method uses parent and child pointer structures to interconnect rows and form a tree structure. On one hand, it uses dynamically allocated structures to store each non-zero segment of data in a row, requiring the allocation and storage of a large number of intermediate structures until the image scanning ends. On the other hand, connecting two structures or trees requires traversing the tree to modify pointers and tree numbers. Due to the dynamic memory allocation and tree traversal operations, the image line-by-line scanning fast clustering method is difficult to implement in parallel on an FPGA unless the image size is very small (e.g., 256x256 pixels, in which case a storage space completely covering the image size is allocated, and tree traversal is not required).

[0007] The seed 4 (8) neighborhood clustering method clusters around the seed. Since image data is generally input line by line, it is difficult to select seed points. For concave structure targets, there is also a tree traversal problem when circling. Therefore, this clustering method has not been implemented in parallel on FPGA. Summary of the Invention

[0008] The purpose of this invention is to improve the running speed and solve the bottleneck of star sensor output frame rate by utilizing the parallel computing characteristics of FPGA.

[0009] The technical solution of this invention is: to provide an FPGA parallel computing method for star target extraction suitable for star sensors, the method comprising:

[0010] High-pass filtering convolution is used to remove stray light background from the star sensor image, and Robinson_Guard filtering is used to suppress background noise to generate an image containing star targets and high-frequency noise. The high-pass filtering uses a 13×13 edge high-pass filter template to convolve the image, and the Robinson_Guard filtering uses a 13×13 template based on the guard band. The filter output value of the center point is calculated through the pixels outside the guard band to ensure that the upper limit of the size of small targets in the image is 13×13 pixels.

[0011] The preprocessed pixels are placed into a pixel buffer queue with a depth of 24 according to the pixel clock. This queue is used to buffer synchronization data. Thirteen 14-bit FIFOs with a width equal to the image row width are allocated for row splitting of pixel data. An asynchronous clock is set, which is at least twice the pixel clock. When the clustering process is idle, the buffer queue data is sent to the latest FIFO. After a 13-row delay, 13 pixels in the same column are output for each input pixel.

[0012] Allocate 13 groups of 25 14-bit registers each in a dual-port bram as the clustering data area FindArea_bram_13, starting storage from the middle position to ensure all targets are included in the frame; allocate 25 groups of 7 8-bit registers each in a dram as RowCluster_dram to record the clustering data of each column, with the data format being 4 bits for the starting position plus 4 bits for the length;

[0013] For each column of pixels output, the data in the current column is clustered into a maximum of 7 clusters based on whether the pixel is 0, and these clusters are stored in RowCluster_dram;

[0014] After a 13-column delay, target clustering begins, starting with the first non-zero cluster number in the middle 12th column. Clusters are compared with and merged with the clusters on either side. A 40-depth heap FIFO is used to store the clustering data, with the data format being 5 bits for the column number, 4 bits for the position, and 4 bits for the length. The initial cluster number and column position are pushed into the heap, while the original cluster number is cleared, and the corresponding pixel grayscale is extracted to calculate the target centroid. When the heap is not empty, clusters are popped, and adjacent clusters are searched and pushed into the heap in a left-to-right order, repeating until the heap is empty. Simultaneously, the target data is statistically analyzed and stored in the structure OBJ_CLUSTER, including the leftmost, rightmost, topmost, and bottommost positions, pixel count, and grayscale sum.

[0015] After discarding the false target, two sets of 10 register arrays are established as the sorted output target structure. One set stores temporary data and uses 3 clock cycles to complete the interpolation. The new target is compared with the grayscale of the target in the sorting queue and inserted into the appropriate position in the queue. The target is then sorted by grayscale and output.

[0016] In any of the above technical solutions, the high-pass filtering is further implemented using a high-pass filtering operator, and the specific form of the high-pass filtering operator H is as follows:

[0017] .

[0018] In any of the above technical solutions, the Robinson Guard filter further calculates the center point using pixels outside the guard band. The filtered output value, whose filter operator H i The specific form is:

[0019] ;

[0020] The output of the Robinson Guard filter Represented as:

[0021] ;

[0022] in, express Original pixel grayscale, max(z) i () represents the highest grayscale value among all pixels within the guard band area.

[0023] In any of the above technical solutions, the conditions for discarding false targets further include: discarding if the length or width is less than 3 pixels; discarding if the aspect ratio is greater than 3; and discarding if the grayscale and / or average grayscale is less than a preset threshold.

[0024] The beneficial effects of this invention are:

[0025] This invention leverages the parallel computing capabilities of FPGAs to improve star clustering from traditional row-by-row scanning to column-by-column scanning, achieving simultaneous parallel processing of image processing and star detection. Star extraction can be completed simultaneously with image acquisition, completely overcoming the computational speed bottleneck caused by megapixel-level large-size star images and enabling full frame rate output.

[0026] This invention, targeting the characteristics of star point targets in star sensors, cleverly utilizes preprocessing filters (such as RobinsonGuard filters) to forcibly limit the maximum length and width dimensions of the targets to be clustered. This approach avoids the problem of requiring a large amount of dynamically allocated storage space in traditional CPU / DSP serial operations, and can complete high-efficiency clustering using only a small amount of FPGA on-chip resources (such as FIFO, BRAM, and DRAM), significantly reducing the dependence on large-capacity external memory.

[0027] This invention addresses the challenge of handling concave target structures or tree traversals in FPGAs using methods such as seed neighborhood clustering, by allocating a FIFO of a specific width and employing heap-based (FIFO) connectivity search logic. The method is logically clear and ensures accurate and complete extraction of target information during column-by-column progression.

[0028] By overcoming the speed bottleneck of image processing and optimizing resource consumption, this method enables star sensors to better adapt to the high-dynamic, high-performance spacecraft attitude measurement requirements. Attached Figure Description

[0029] The advantages of the above and additional aspects of the present invention will become apparent and readily understood in the description of the embodiments in conjunction with the following drawings, wherein:

[0030] Figure 1 This is a target extraction flowchart of an FPGA parallel computing method for star target extraction applicable to star sensors according to an embodiment of the present invention;

[0031] Figure 2 This is a target clustering data flow diagram of a star target extraction FPGA parallel computing method for star sensors according to an embodiment of the present invention;

[0032] Figure 3 This is a schematic diagram of the star map high-pass filtering processing result of an FPGA parallel computing method for star target extraction of a star sensor according to an embodiment of the present invention.

[0033] Figure 4 This is a Robinson Guard filtered image of a star target extraction FPGA parallel computing method for star sensors according to an embodiment of the present invention;

[0034] Figure 5 This is a truth table of cluster number 1 for a star target extraction FPGA parallel computing method applicable to star sensors according to an embodiment of the present invention;

[0035] Figure 6 This is a truth table of cluster number 2 for a star target extraction FPGA parallel computing method applicable to star sensors according to an embodiment of the present invention. Detailed Implementation

[0036] To better understand the above-mentioned objectives, features, and advantages of the present invention, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments. It should be noted that, unless otherwise specified, the embodiments of the present invention and the features thereof can be combined with each other.

[0037] In the following description, many specific details are set forth in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and therefore the scope of protection of the invention is not limited to the specific embodiments disclosed below.

[0038] like Figure 1 As shown, this embodiment provides an FPGA parallel computing method for star target extraction suitable for star sensors. The method includes:

[0039] To address the characteristic of extracting small targets by using star points as small light spots in star sensor images, a special image preprocessing filter is used to forcibly remove long and large background blocks that cannot be star targets, ensuring that the length and width of star targets or noise points that need to be clustered in the image have a maximum upper limit during clustering.

[0040] S1. Preprocess the star sensor image to suppress background and limit target size.

[0041] This preprocessing consists of two steps:

[0042] S11. A 13×13 edge high-pass filter template is used to perform a convolution operation on the image to generate an image containing star targets and high-frequency noise. The high-pass filter template filters out the low-frequency stray light background in the image, while fully preserving the energy of the star targets and not enhancing the high-frequency noise. The specific form of the high-pass filter operator H is as follows:

[0043] ;

[0044] like Figure 2 The image shown is the result of high-pass filtering on a strong stray light image. After image processing, the stray light is completely removed, and the star map only shows the star targets and high-frequency background noise.

[0045] S12. Apply Robinson Guard filtering to the high-pass filtered image to suppress background noise. This filter is a guard-band-based background suppression filter that calculates the center point using pixels outside the guard band. The filtered output value, whose filter operator H i The specific form is:

[0046] ;

[0047] The output of the Robinson Guard filter Represented as:

[0048] ;

[0049] in, express Original pixel grayscale, max(z) i The value represents the highest grayscale value among all pixels within the guard band area. Based on the size of the star target and its motion angular rate, the Robinson Guard filter template in this embodiment is selected as 13×13, which means that the maximum size of the star target or noise point to be clustered in the image is forced to not exceed 13×13 pixels.

[0050] like Figure 3 As shown, this is for Figure 2 The image shown is the result of further Robinson Guard filtering of the high-pass filtering result. It can be seen that after Robinson Guard filtering, low-frequency background and weak background fluctuations in the image are further suppressed, the overall grayscale of the background area approaches zero, and significant responses are retained only in local areas that meet the guard band determination criteria. The star target located at the center of the guard band is effectively preserved because its grayscale is significantly higher than the surrounding background sampling area, and its spatial size is constrained by the filtering template and the width of the guard band, thus appearing as an isolated, size-limited bright spot in the output image. This processing can further highlight the star target without introducing additional connectivity expansion, providing a stable and clear input data foundation for subsequent clustering and target selection based on connected components.

[0051] After the above preprocessing, the star targets and high-frequency noise in the star sensor image are restricted to small targets. This invention utilizes the parallel computing capabilities of FPGAs to improve target clustering from traditional row-by-row scanning to column-by-column scanning, such as... Figure 4 As shown, the clustering extraction process includes:

[0052] S2. Pixel Buffer and Row Delay: After preprocessing, the pixels are first placed into a pixel buffer queue with a depth of 24 according to the pixel clock. When the clustering unit is idle, the queue data is written to FIFO13 in batches. After the data is delayed by cascading through FIFO13→FIFO12→……→FIFO1, 13 pixel samples in the same column can be obtained in each clock cycle and sent to the subsequent column clustering unit to complete the parallel input of column-by-column advancement.

[0053] These FIFOs are 14 bits wide, representing the image row width, and are used to separate pixel data into rows.

[0054] An asynchronous clock, at least twice the pixel clock, is set in the above process. When the clustering process is idle (i.e., after the previous target clustering is completed), the image data in the buffer queue is sent into FIFO13 for the next target clustering. After a delay of 13 rows, each number sent into the FIFO will output 13 numbers in the same column.

[0055] S3. Target window data area and column clustering table allocation: Allocate 13 groups of 25 14-bit register arrays FindArea_bram_13 to store local window data based on the target size upper limit of 13×13. The 12th column at the center of the column number is used as the decision column during clustering. The pixel data window of the nearest 25 columns is retained. At the same time, maintain 25 groups of RowCluster_dram, with each column corresponding to 7 clustering record positions and lengths for subsequent merging and determination.

[0056] S4. Clustering identification and RowCluster writing for each output column: For each output column, detect the connected segments within the column based on whether the pixel is zero. Encode the up to 7 connected segments in the column (up to 7 clusters in 13 columns, with the number of clusters ≤ 7) into the starting position + length and write them into the corresponding RowCluster_dram.

[0057] In this step, each cluster number has a truth table, where the truth table for cluster number 1 is as follows: Figure 5 As shown, the truth table for cluster number 2 is as follows: Figure 6 As shown, the truth tables for subsequent cluster numbers 3 to 7 are similar to the first two and will not be given separately.

[0058] S5. Center Column Clustering Trigger and Heap Advance Merging: After the pixel data is advanced column by column and a 13-column delay is completed, the center column of the current window, i.e., the 7 cluster records corresponding to the 12th column, is read from FindArea_bram_13. If the first cluster record in the 12th column is non-zero, it is considered that a new cluster to be merged has been detected. The column number, starting position, and length information of the corresponding cluster are written into the cluster heap, and the corresponding cluster record in RowCluster_dram is cleared to avoid repeated participation in subsequent clustering processes.

[0059] While writing the cluster to the heap, the corresponding pixel grayscale data is read from FindArea_bram_13 according to its starting position and length. The pixel grayscale value and the number of pixels are accumulated separately for subsequent target centroid calculation. The numerator and denominator of the centroid calculation are completed through multiple accumulations to adapt to the hardware bit width limit.

[0060] When the cluster heap is not empty, a cluster record is retrieved from the heap. Following the order of left column first, then right column, the RowCluster_dram is searched for adjacent column records spatially connected to this cluster. If adjacent clusters exist, the column number, starting position, and length information of the adjacent cluster are written to the heap, and the corresponding record in RowCluster_dram is cleared. Simultaneously, the pixel grayscale and pixel count corresponding to the adjacent cluster are continuously accumulated and statistically analyzed.

[0061] Repeat the above process of popping out of the heap, searching for adjacent columns, and popping into the heap until the cluster heap is empty, thereby completing the overall clustering and merging of connected targets and the summarization of pixel information starting from the clustering triggered by column 12.

[0062] S6. Current target structure filling: During the heap-driven merging process, an OBJ_CLUSTER register array is maintained and updated to record the current target's boundary, total number of pixels, and grayscale sum.

[0063] S7. False Target Filtering: Apply filtering criteria to the completed OBJ_CLUSTER to discard false targets. The discarding conditions include: if the length or width is less than 3 pixels, discard it; if the aspect ratio is greater than 3, discard it; if the gray level and / or average gray level is less than a preset threshold, discard it.

[0064] S8. Output Sorting and Queue Maintenance: Establish two OBJ register arrays, each with 10 entries, for sorting the output target structure. Interpolation is completed using 3 clock cycles. One array stores the current sorting queue, and the other serves as a temporary buffer. The new target is compared with the target grayscale values ​​in the sorting queue, and interpolated into the appropriate position in the queue.

[0065] In summary, this invention proposes an FPGA parallel computing method for star target extraction suitable for star sensors, comprising:

[0066] High-pass filtering convolution is used to remove stray light background from the star sensor image, and Robinson_Guard filtering is used to suppress background noise to generate an image containing star targets and high-frequency noise. The high-pass filtering uses a 13×13 edge high-pass filter template to convolve the image, and the Robinson_Guard filtering uses a 13×13 template based on the guard band. The filter output value of the center point is calculated through the pixels outside the guard band to ensure that the upper limit of the size of small targets in the image is 13×13 pixels.

[0067] The preprocessed pixels are placed into a pixel buffer queue with a depth of 24 according to the pixel clock. This queue is used to buffer synchronization data. Thirteen 14-bit FIFOs with a width equal to the image row width are allocated for row splitting of pixel data. An asynchronous clock is set, which is at least twice the pixel clock. When the clustering process is idle, the buffer queue data is sent to the latest FIFO. After a 13-row delay, 13 pixels in the same column are output for each input pixel.

[0068] Allocate 13 groups of 25 14-bit registers each in a dual-port bram as the clustering data area FindArea_bram_13, starting storage from the middle position to ensure all targets are included in the frame; allocate 25 groups of 7 8-bit registers each in a dram as RowCluster_dram to record the clustering data of each column, with the data format being 4 bits for the starting position plus 4 bits for the length;

[0069] For each column of pixels output, the data in the current column is clustered into a maximum of 7 clusters based on whether the pixel is 0, and these clusters are stored in RowCluster_dram;

[0070] After a 13-column delay, target clustering begins, starting with the first non-zero cluster number in the middle 12th column. Clusters are compared with and merged with the clusters on either side. A 40-depth heap FIFO is used to store the clustering data, with the data format being 5 bits for the column number, 4 bits for the position, and 4 bits for the length. The initial cluster number and column position are pushed into the heap, while the original cluster number is cleared, and the corresponding pixel grayscale is extracted to calculate the target centroid. When the heap is not empty, clusters are popped, and adjacent clusters are searched and pushed into the heap in a left-to-right order, repeating until the heap is empty. Simultaneously, the target data is statistically analyzed and stored in the structure OBJ_CLUSTER, including the leftmost, rightmost, topmost, and bottommost positions, pixel count, and grayscale sum.

[0071] After discarding the false target, two sets of 10 register arrays are established as the sorted output target structure. One set stores temporary data and uses 3 clock cycles to complete the interpolation. The new target is compared with the grayscale of the target in the sorting queue and inserted into the appropriate position in the queue. The target is then sorted by grayscale and output.

[0072] The steps in this invention can be adjusted, combined, or deleted according to actual needs.

[0073] The units in the device of the present invention can be merged, divided, or reduced according to actual needs.

[0074] In this invention, the terms "installation," "connection," "linking," and "fixing" should be interpreted broadly. For example, "connection" can be a fixed connection, a detachable connection, or an integral connection; "linking" can be a direct connection or an indirect connection through an intermediate medium. Those skilled in the art can understand the specific meaning of these terms in this invention according to the specific circumstances.

[0075] The shapes of the components in the accompanying drawings are schematic and may differ from their actual shapes. The drawings are only used to illustrate the principles of the present invention and are not intended to limit the present invention.

[0076] Although the invention has been disclosed in detail with reference to the accompanying drawings, it should be understood that these descriptions are merely exemplary and not intended to limit the application of the invention. The scope of protection of the invention is defined by the appended claims and may include various modifications, alterations, and equivalents made to the invention without departing from the scope and spirit of the invention.

Claims

1. An FPGA parallel computing method for star target extraction suitable for star sensors, characterized in that, The method includes: High-pass filtering convolution is used to remove stray light background from the star sensor image, and Robinson_Guard filtering is used to suppress background noise to generate an image containing star targets and high-frequency noise. The high-pass filtering uses a 13×13 edge high-pass filter template to convolve the image, and the Robinson_Guard filtering uses a 13×13 template based on the guard band. The filter output value of the center point is calculated through the pixels outside the guard band to ensure that the upper limit of the size of small targets in the image is 13×13 pixels. The preprocessed pixels are placed into a pixel buffer queue with a depth of 24 according to the pixel clock. This queue is used to buffer synchronization data. Thirteen 14-bit FIFOs with a width equal to the image row width are allocated for row splitting of pixel data. An asynchronous clock is set, which is at least twice the pixel clock. When the clustering process is idle, the buffer queue data is sent to the latest FIFO. After a 13-row delay, 13 pixels in the same column are output for each input pixel. Allocate 13 groups of 25 14-bit registers each in a dual-port bram as the clustering data area FindArea_bram_13, starting storage from the middle position to ensure all targets are included in the frame; allocate 25 groups of 7 8-bit registers each in a dram as RowCluster_dram to record the clustering data of each column, with the data format being 4 bits for the starting position plus 4 bits for the length; For each column of pixels output, the data in the current column is clustered into a maximum of 7 clusters based on whether the pixel is 0, and these clusters are stored in RowCluster_dram; After a 13-column delay, target clustering begins, starting with the first non-zero cluster number in the middle 12th column. Clusters are compared with and merged with the clusters on either side. A 40-depth heap FIFO is used to store the clustering data, with the data format being 5 bits for the column number, 4 bits for the position, and 4 bits for the length. The initial cluster number and column position are pushed into the heap, while the original cluster number is cleared, and the corresponding pixel grayscale is extracted to calculate the target centroid. When the heap is not empty, clusters are popped, and adjacent clusters are searched and pushed into the heap in a left-to-right order, repeating until the heap is empty. Simultaneously, the target data is statistically analyzed and stored in the structure OBJ_CLUSTER, including the leftmost, rightmost, topmost, and bottommost positions, pixel count, and grayscale sum. After discarding the false target, two sets of 10 register arrays are established as the sorted output target structure. One set stores temporary data and uses 3 clock cycles to complete the interpolation. The new target is compared with the grayscale of the target in the sorting queue and inserted into the appropriate position in the queue. The target is then sorted by grayscale and output.

2. The FPGA parallel computing method for star target extraction suitable for star sensors as described in claim 1, characterized in that, The high-pass filtering is implemented using a high-pass filtering operator, and the specific form of the high-pass filtering operator H is as follows: 。 3. The FPGA parallel computing method for star target extraction suitable for star sensors as described in claim 1, characterized in that, The Robinson Guard filter calculates the center point using pixels outside the guard band. The filtered output value, whose filter operator H i The specific form is as follows: ； The output of the Robinson Guard filter Represented as: ； in, express Original pixel grayscale, max(z) i () represents the highest grayscale value among all pixels within the guard band area.

4. The FPGA parallel computing method for star target extraction suitable for star sensors as described in claim 1, characterized in that, The conditions for discarding pseudo-targets include: discarding if the length or width is less than 3 pixels; discarding if the aspect ratio is greater than 3; and discarding if the grayscale and / or average grayscale is less than a preset threshold.

Images