Image processing systems, methods and processing equipment

By combining memory, address generator, pipelined cache module and filtering operation module, the problems of low hardware throughput and resource redundancy in FPGA hardware image filtering are solved, realizing high-speed image processing at the thousand-frame level, reducing hardware cost and improving adaptability.

CN123118347APending Publication Date: 2026-11-17BEIJING WEIJING OPTICAL TECH CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611611269.2
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-10-19
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

Existing FPGA hardware image filtering methods suffer from low hardware throughput, resource redundancy, and inability to reuse algorithms, failing to meet the real-time processing requirements of high-speed imaging at the thousand-frame level.

Method used

A combined design of memory, address generator, pipelined cache module, filtering operation module and state machine controller is adopted to realize parallel row caching and filtering processing, and the row cache, address generator and state machine controller are shared, saving hardware resources.

Benefits of technology

It achieves high-speed parallel filtering processing of grayscale images at the thousand-frame level, reduces hardware costs, improves versatility and portability, and is compatible with various FPGA models.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123118347A_ABST
    Figure CN123118347A_ABST
Patent Text Reader

Abstract

This application relates to an image processing system, method, and processing device. In the system, a state machine controller controls a memory to receive an original image for caching, and controls an address generator to read the storage address of the original image from the memory line by line. The state machine controller controls a pipelined cache module to obtain the storage addresses of each line read by the address generator, so that the pipelined cache module reads the pixels of the original image in parallel based on the storage addresses of each line and a preset number of lines, and outputs neighborhood pixels based on a preset pixel template. The state machine controller controls a filtering operation module to filter the received neighborhood pixels to obtain filtered pixels, and transmits the filtered pixels to a memory, so that the memory outputs a target filtered image based on the filtered pixels. This achieves high-speed parallel filtering processing of grayscale images at the thousand-frame level, saving FPGA hardware resources, reducing hardware costs, and improving versatility and portability.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the field of image processing technology, and more particularly to an image processing system, method and processing device. Background Technology

[0002] Image filtering is generally divided into software filtering and FPGA hardware filtering. Among them, software filtering relies on serial operation of a general-purpose processor, traversing the 128×128 neighborhood pixel by pixel. This results in high computational latency and low frame rate. For example, a 640×512 resolution image can only achieve tens of frames per second, which cannot meet the real-time processing requirements of high-speed imaging at the thousand-frame level and is not suitable for embedded high-speed optoelectronic devices.

[0003] In traditional FPGA hardware filtering methods, the row buffer design is rudimentary, often using a single set of shift registers to buffer a single row of data. When reading multiple rows of neighboring pixels, there are pipeline interruptions and waiting for idle cycles, resulting in low throughput and the inability to output a single pixel in a single clock cycle. Traditional filter designs have two independent hardware designs for reading and writing, resulting in resource redundancy and the inability to reuse row buffers, address generation, and state machine control modules. The memory interface can only read a single byte of pixel at a time, and the memory access bottleneck limits the overall pipeline throughput. Summary of the Invention

[0004] The purpose of this application is to provide an image processing system, method, and processing device to solve the problems of low hardware throughput, resource redundancy, and inability to reuse algorithms in existing FPGA hardware image filtering methods.

[0005] In a first aspect, this application provides an image processing system, comprising: Memory; An address generator is connected to the memory. Pipeline buffer module, which connects the address generator and the memory; The filtering operation module is connected to the pipeline buffer module and the memory. The state machine controller is connected to the memory, address generator, pipelined buffer module, and filtering operation module respectively. The state machine controller is used to control the memory to receive the original image so that the original image can be cached in the memory, and to control the address generator to read the storage address of the original image in the memory line by line. The state machine controller is also used to control the pipeline buffer module to obtain the storage addresses of each row read by the address generator, so that the pipeline buffer module reads the pixels of the original image in parallel based on the storage addresses of each row and the preset number of rows, and outputs the neighborhood pixels based on the preset pixel template. The state machine controller is also used to control the filtering operation module to receive neighborhood pixels, perform filtering on the neighborhood pixels to obtain filtered pixels, and transmit the filtered pixels to the memory so that the memory can output the target filtered image based on the filtered pixels.

[0006] In one embodiment, the pipelined buffer module is used to perform boundary recognition on the pixels of the parallel-buffered original image to obtain each boundary pixel point, and fill each boundary pixel point with a preset value to obtain a target buffer pixel sequence; the pipelined buffer module is also used to output the target buffer pixel sequence based on a preset pixel template to obtain neighborhood pixels.

[0007] In one embodiment, the target cached pixel sequence includes an upper padding boundary, a lower padding boundary, a left padding boundary, and a right padding boundary; The upper and lower fill boundaries are obtained by filling with preset values ​​using preset software; the left and right fill boundaries are obtained by filling with preset values ​​using the pipeline buffer module.

[0008] In one embodiment, the pipelined buffer module includes multiple sets of row registers and shift buffer registers; the shift buffer registers are connected to each set of row registers. The row register is used to cache the corresponding row pixels of the original image based on the storage address of the corresponding row; the shift buffer register is used to obtain the corresponding number of pixels cached in each row register based on a preset pixel template, thus obtaining the neighborhood pixels.

[0009] In one embodiment, the filtering operation module includes a hierarchical parallel sorting module; The hierarchical parallel sorting module connects the pipeline buffer module, the state machine controller, and the memory; The state machine controller is used to control the hierarchical parallel sorting module to receive neighborhood pixels, so that the hierarchical parallel sorting module performs pixel sorting processing on the neighborhood pixels to obtain sorted pixels, performs median filtering processing on the sorted pixels to obtain filtered pixels, and transmits the filtered pixels to the memory so that the memory outputs the target filtered image based on the filtered pixels.

[0010] In one embodiment, the hierarchical parallel sorting module includes a multi-level comparator and an extraction module. The multi-level comparator is connected to the state machine controller and the pipeline buffer module; the extraction module is connected to the multi-level comparator and the memory. A multi-level comparator is used to compare the pixel values ​​of each pixel in the input neighborhood pixel and sort the pixels in the neighborhood pixel based on the size of the pixel values ​​to obtain sorted pixels. The extraction module is used to extract the median of the sorted pixels, obtain the median of the pixels, and update the value of the center pixel of the neighborhood pixels to the median of the pixels, thus obtaining the filtered pixels.

[0011] In one embodiment, the filtering module further includes a convolution module; The convolution module connects to the pipeline buffer module, memory, and state machine controller; The state machine controller is also used to control the convolution module to acquire neighborhood pixels, perform convolution processing on the neighborhood pixels to obtain convolutional pixels, and transmit the convolutional pixels to the memory so that the memory can output the target filtered image based on the convolutional pixels.

[0012] In one embodiment, the convolution module is used to process the horizontal and vertical gradients of the neighborhood pixels to obtain the horizontal gradient values ​​and the vertical gradient values, and to perform absolute value summation on the corresponding horizontal gradient values ​​and the corresponding vertical gradient values ​​to obtain the gradient magnitude of the corresponding pixel. Based on the gradient magnitude of each pixel, the convolved pixel is obtained.

[0013] Secondly, this application also provides an image processing method applied to an image processing system as described in any of the above claims, the method comprising: The control memory receives the original image, so that the original image is cached in the memory, and the control address generator reads the storage address of the original image in the memory line by line; The pipeline buffer module is controlled to obtain the storage addresses of each row read by the address generator, so that the pipeline buffer module reads the pixels of the original image in parallel based on the storage addresses of each row and the preset number of rows, and outputs the neighborhood pixels based on the preset pixel template. The control filtering operation module receives neighborhood pixels, performs filtering processing on the neighborhood pixels to obtain filtered pixels, and transmits the filtered pixels to the memory so that the memory can output the target filtered image based on the filtered pixels.

[0014] Thirdly, this application also provides a processing device, including an image acquisition module and an image processing system as described in any of the above claims; the image acquisition module is connected to the image processing system.

[0015] One of the above technical solutions has the following advantages and beneficial effects: The image processing system described above includes a memory, an address generator, a pipelined buffer module, a filtering operation module, and a state machine controller. The address generator is connected to the memory; the pipelined buffer module is connected to both the address generator and the memory; the filtering operation module is connected to both the pipelined buffer module and the memory; and the state machine controller is connected to the memory, the address generator, the pipelined buffer module, and the filtering operation module. The state machine controller controls the memory to receive the original image for caching, and controls the address generator to read the storage address of the original image line by line from the memory. The state machine controller also controls the pipelined buffer module to obtain the storage addresses of each line read by the address generator, so that the pipelined buffer module reads the pixels of the original image in parallel based on the storage address of each line and a preset number of lines, and outputs neighborhood pixels based on a preset pixel template. The state machine controller also controls the filtering operation module to receive neighborhood pixels, perform filtering on the neighborhood pixels to obtain filtered pixels, and transmit the filtered pixels to the memory, so that the memory outputs the target filtered image based on the filtered pixels, enabling high-speed parallel filtering processing of grayscale images at the thousand-frame level. This application uses memory to cache the original image, and builds a pipelined cache module and a filtering operation module, which can process thousands of frames of images at high speed and stably. It shares the row cache, address generator and state machine controller, which saves FPGA hardware resources, can be deployed with small and medium capacity FPGAs, reduces hardware costs, and can be adapted to various FPGA models, improving versatility and portability. Attached Figure Description

[0016] Figure 1 This is a first structural schematic diagram of the image processing system in an embodiment of this application; Figure 2 This is a schematic diagram of the second structure of the image processing system in an embodiment of this application; Figure 3 This is a schematic diagram of the third structure of the image processing system in an embodiment of this application; Figure 4 This is a schematic diagram of the fourth structure of the image processing system in the embodiments of this application; Figure 5 This is a schematic diagram of the original noise-free image in an embodiment of this application; Figure 6 This is a schematic diagram of an image with noise added in an embodiment of this application; Figure 7 This is a schematic diagram of the target filtered image in an embodiment of this application; Figure 8 This is a flowchart illustrating the image processing method in an embodiment of this application.

[0017] Figure label: 10. Memory; 20. Address generator; 30. Pipeline buffer module; 310. Row register; 320. Shift buffer register; 40. Filtering module; 410. Hierarchical parallel sorting module; 412. Multi-stage comparator; 414. Extraction module; 420. Convolution module; 50. State machine controller. Detailed Implementation

[0018] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort should fall within the scope of protection of the present application.

[0019] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate for the embodiments of this application described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0020] In addition, the term "multiple" should mean two or more.

[0021] It should be noted that, unless otherwise specified, the embodiments and features described in this application can be combined with each other. This application will now be described in detail with reference to the accompanying drawings and embodiments.

[0022] In one embodiment, such as Figure 1As shown, an image processing system is provided, including a memory 10, an address generator 20, a pipelined buffer module 30, a filtering operation module 40, and a state machine controller 50. The address generator 20 is connected to the memory 10; the pipelined buffer module 30 is connected to the address generator 20 and the memory 10; the filtering operation module 40 is connected to the pipelined buffer module 30 and the memory 10; the state machine controller 50 is connected to the memory 10, the address generator 20, the pipelined buffer module 30, and the filtering operation module 40 respectively; the state machine controller 50 is used to control the memory 10 to receive the original image, so as to buffer the original image through the memory 10, and control the state machine controller to receive the original image. The address generator 20 reads the storage address of the original image in the memory 10 line by line; the state machine controller 50 is also used to control the pipeline buffer module 30 to obtain the storage address of each line read by the address generator 20, so that the pipeline buffer module 30 reads the pixels of the original image in parallel according to the storage address of each line and based on the preset number of lines, and outputs the neighborhood pixels based on the preset pixel template; the state machine controller 50 is also used to control the filtering operation module 40 to receive the neighborhood pixels, perform filtering processing on the neighborhood pixels to obtain the filtered pixels, and transmit the filtered pixels to the memory 10, so that the memory 10 outputs the target filtered image according to the filtered pixels.

[0023] The memory 10 employs an on-chip simulated SRAM memory. The read / write bus of the memory 10 can be a 32-bit four-pixel parallel SRAM read / write bus, supporting hex file read / write. The memory 10 is used to store the original image and also to output the target filtered image. The address generator 20 refers to a global address generator 20, which can be used to multiplex the read / write address timing of the filtering operation module 40 to output the storage addresses of the original image and the target filtered image.

[0024] The pipeline buffer module 30 can be a three-row pixel pipeline buffer module 30. For example, the pipeline buffer module 30 has three sets of 32-bit row registers 310 and shift buffer registers 320 built in, and outputs the neighborhood pixels of the preset pixel template in parallel. For example, the preset pixel module can be a 3×3 pixel template, and the pipeline buffer module 30 can output nine 8-bit neighborhood pixels in parallel. The filtering operation module 40 is used to filter the neighborhood pixels of the corresponding original image and transmit the filtered pixels to the memory 10. The state machine controller 50 refers to the global finite state machine controller 50, which is used to uniformly output memory 10 read / write, row buffer loading, and pipeline enable, etc. It should be noted that the memory 10, address generator 20, pipeline buffer module 30, filtering operation module 40, and state machine controller 50 share the clock signal clk (up to 400MHz) and the low-level reset signal rst_n to achieve global unified clock reset. It should be noted that the state machine controller 50 is divided into five states: reset, image reading, pipeline operation, image write-back, and completion. It automatically counts all pixels of the original image and raises the filtering completion flag when it is completed. No external real-time control is required throughout the process.

[0025] For example, the state machine controller 50 controls the memory 10 to receive the original image (such as a 640×512 grayscale image) to cache the original image in the memory 10, and controls the address generator 20 to read the storage address of the original image in the memory 10 line by line; so that the pipelined cache module 30 obtains the storage address of each line read by the address generator 20, so that the pipelined cache module 30 reads the 32-bit pixels of the original image in parallel based on the storage address of each line and a preset number of lines (such as three lines), and outputs 9 channels of 8-bit neighborhood pixels based on a preset pixel template (such as a 3×3 pixel template); the state machine controller 50 controls the filtering operation module 40 to receive the 9 channels of 8-bit neighborhood pixels, and performs filtering processing on the 9 channels of 8-bit neighborhood pixels to obtain filtered pixels, and packs the filtered pixels into 32-bit four-pixel packages and writes them back to the memory 10, so that the memory 10 outputs the target filtered image based on the filtered pixels.

[0026] In the above embodiments, address generator 20 is connected to memory 10, pipelined cache module 30 is connected to address generator 20 and memory 10, filtering operation module 40 is connected to pipelined cache module 30 and memory 10, and state machine controller 50 is connected to memory 10, address generator 20, pipelined cache module 30 and filtering operation module 40 respectively; state machine controller 50 controls memory 10 to receive the original image so as to cache the original image through memory 10, and controls address generator 20 to read the storage address of the original image in memory 10 line by line; state machine controller 50 The pipelined buffer module 30 obtains the storage addresses of each row read by the address generator 20, enabling it to read pixels from the original image in parallel based on a preset number of rows according to the storage addresses, and output neighborhood pixels based on a preset pixel template. The state machine controller 50 controls the filtering operation module 40 to receive neighborhood pixels, perform filtering on them, obtain filtered pixels, and transmit them to the memory 10, so that the memory 10 can output the target filtered image based on the filtered pixels. This enables high-speed parallel filtering processing of grayscale images at the thousand-frame level. By using the memory 10 to buffer the original image and building the pipelined buffer module 30 and the filtering operation module 40, high-speed and stable processing of images at the thousand-frame level can be achieved. Sharing the row buffer, address generator 20, and state machine controller 50 saves FPGA hardware resources, allowing deployment with small to medium-capacity FPGAs, reducing hardware costs, and adapting to various FPGA models, thus improving versatility and portability.

[0027] In one embodiment, the pipelined buffer module 30 is used to perform boundary recognition on the pixels of the parallel-buffered original image to obtain each boundary pixel point, and fill each boundary pixel point with a preset value to obtain a target buffer pixel sequence; the pipelined buffer module 30 is also used to output the target buffer pixel sequence based on a preset pixel template to obtain neighborhood pixels.

[0028] Here, boundary pixels refer to the pixels in the first row, last row, first column, and last column. For example, the preset value can be 0. The state machine controller 50 is also used to transmit boundary zeroing control signals to the pipeline buffer module 30, so that the pipeline buffer module 30 sequentially selects each pixel as a reference pixel, identifies adjacent pixels for the reference pixel, and determines that the reference pixel is a non-boundary pixel if the reference pixel has complete adjacent pixels; if the reference pixel is missing at least one similar pixel, it is determined that the reference pixel is a boundary pixel, and then the value of the identified boundary pixel is updated to 0 to obtain the target buffer pixel sequence. Based on the preset pixel template, the target buffer pixel sequence is output to obtain the neighborhood pixels, which are then transmitted to the filtering operation module for processing. This realizes integrated hardware boundary zeroing logic, reduces front-end buffer overhead, and simplifies the back-end system.

[0029] In one embodiment, the target cached pixel sequence includes an upper padding boundary, a lower padding boundary, a left padding boundary, and a right padding boundary; the upper and lower padding boundaries are obtained by filling with preset values ​​using preset software; the left and right padding boundaries are obtained by filling with preset values ​​using the pipelined cache module 30.

[0030] The upper padding boundary refers to the boundary pixels of the first row of the original image pixels cached in parallel by the pipeline cache module 30; the lower padding boundary refers to the boundary pixels of the last row of the original image pixels cached in parallel by the pipeline cache module 30; the left padding boundary refers to the boundary pixels of the first column of the original image pixels cached in parallel by the pipeline cache module 30; and the right padding boundary refers to the boundary pixels of the last column of the original image pixels cached in parallel by the pipeline cache module 30.

[0031] For example, preset software such as OpenCV or MATLAB can be used to fill each pixel in the first row and the last row with preset values ​​(such as 0), thus obtaining the upper and lower fill boundaries. The pipelined buffer module 30 updates the values ​​of each pixel in the first and last columns to preset values ​​(such as 0), thus obtaining the left and right fill boundaries. This simplifies the integration of hardware-based automatic zero-padding logic for left and right boundaries in the front-end and back-end links of the system. Only a small number of upper and lower boundaries need to be processed by software, eliminating the need for image boundary preprocessing steps on the host computer and reducing the data interaction overhead between the CPU and FPGA.

[0032] In one embodiment, such as Figure 2As shown, the pipeline buffer module 30 includes multiple sets of row registers 310 and shift buffer registers 320; the shift buffer registers 320 are connected to each set of row registers 310; the row registers 310 are used to buffer the corresponding row pixels of the original image based on the storage address of the corresponding row; the shift buffer registers 320 are used to obtain the corresponding number of pixels buffered by each row register 310 based on a preset pixel template to obtain the neighborhood pixels.

[0033] For example, the pipelined buffer module 30 includes three sets of row registers 310, which are divided into three 32-bit row registers: front row, middle row, and back row. The pipelined buffer module 30 uses a 32-bit bus and reads four 8-bit pixels at a time, storing them in the three 32-bit row registers 310 respectively. The shift buffer register 320 shifts right by 8 bits per frame, continuously outputting 9 channels of 8-bit neighborhood pixels corresponding to the 3×3 pixel template (Z1-Z9), achieving synchronous output of any pixel neighborhood. Then, the state machine controller 50 controls the filtering operation module 40 to receive the 9 channels of 8-bit neighborhood pixels and perform filtering processing on the 9 channels of 8-bit neighborhood pixels to obtain filtered pixels. The filtered pixels are then packaged into 32-bit four-pixel packets and written back to the memory 10, so that the memory 10 can output the target filtered image based on the filtered pixels. This achieves high-speed and stable processing of thousands of frames of images, saves FPGA hardware resources, reduces hardware costs, and can be adapted to various FPGA models, improving versatility and portability.

[0034] In one embodiment, such as Figure 3 As shown, the filtering operation module 40 includes a hierarchical parallel sorting module 410; the hierarchical parallel sorting module 410 is connected to the pipeline buffer module 30, the state machine controller 50, and the memory 10; the state machine controller 50 is used to control the hierarchical parallel sorting module 410 to receive neighborhood pixels, so that the hierarchical parallel sorting module 410 performs pixel sorting processing on the neighborhood pixels to obtain sorted pixels, performs median filtering processing on the sorted pixels to obtain filtered pixels, and transmits the filtered pixels to the memory 10, so that the memory 10 outputs the target filtered image based on the filtered pixels.

[0035] For example, the hierarchical parallel sorting module 410 can employ a 5-level hierarchical parallel bubble array. The 9-channel 8-bit neighborhood pixel synchronous input hierarchical parallel sorting module 410 sorts the neighborhood pixels by pixel values ​​from smallest to largest or largest to smallest, obtaining sorted pixels. It then performs median filtering on the sorted pixels to obtain filtered pixels, which are then transmitted to the memory 10. The memory 10 then outputs the target filtered image based on the filtered pixels, achieving high-speed and stable processing of thousands of frames of images. This saves FPGA hardware resources, reduces hardware costs, and is compatible with various FPGA models, improving versatility and portability.

[0036] In one embodiment, such as Figure 4 As shown, the hierarchical parallel sorting module 410 includes a multi-level comparator 412 and an extraction module 414. The multi-level comparator 412 is connected to the state machine controller 50 and the pipeline buffer module 30; the extraction module 414 is connected to the multi-level comparator 412 and the memory 10. The multi-level comparator 412 is used to compare the pixel values ​​of each pixel in the input neighborhood pixels and sort the pixels in the neighborhood pixels based on the pixel values ​​to obtain sorted pixels. The extraction module 414 is used to extract the median of the pixels in the sorted pixels to obtain the median of the pixels and update the center pixel value of the neighborhood pixels to the median of the pixels to obtain filtered pixels.

[0037] The number of stages in the multi-stage comparator 412 can be determined based on the number of input paths for the neighborhood pixels. For example, for 9 8-bit neighborhood pixels, a 9-stage comparator is used.

[0038] For example, nine 8-bit neighborhood pixels are synchronously input into a multi-level comparator 412. The multi-level comparator 412 compares the values ​​of each pixel in the input neighborhood pixels to separate registers with different values ​​layer by layer, compress the number of comparison levels layer by layer, eliminate long serial combination paths, and then sort the pixels in the neighborhood pixels based on the size of the pixel values ​​to obtain sorted pixels. The extraction module 414 extracts the value of the fifth pixel in the sorted pixels and updates the value of the center pixel of the neighborhood pixels to the median value of the pixels, thereby obtaining the denoised 8-bit filtered pixels.

[0039] In one embodiment, such as Figure 3 As shown, the filtering operation module 40 also includes a convolution module 420; the convolution module 420 is connected to the pipeline buffer module 30, the memory 10 and the state machine controller 50; the state machine controller 50 is also used to control the convolution module 420 to acquire neighborhood pixels, perform convolution processing on the neighborhood pixels to obtain convolutional pixels, and transmit the convolutional pixels to the memory 10 so that the memory 10 outputs the target filtered image based on the convolutional pixels.

[0040] For example, nine 8-bit neighborhood pixels are input into the convolution module 420, and the convolution module 420 performs convolution processing on the neighborhood pixels to obtain filtered convolutional pixels. The convolutional pixels are then transmitted to the memory 10 so that the memory 10 can output the target filtered image based on the convolutional pixels. This achieves high-speed and stable filtering processing of thousands of frames of images, saves FPGA hardware resources, reduces hardware costs, and can be adapted to various FPGA models, improving versatility and portability.

[0041] In one embodiment, the convolution module 420 is used to process the horizontal and vertical gradients of the neighborhood pixels to obtain the horizontal gradient values ​​and the vertical gradient values, and to perform absolute value summation on the corresponding horizontal gradient values ​​and the corresponding vertical gradient values ​​to obtain the gradient magnitude of the corresponding pixel, and to obtain the convolved pixel based on the gradient magnitude of each pixel.

[0042] For example, the convolution module 420 separates the neighborhood pixels of the corresponding 3×3 pixel template in the X and Y directions, calculates the horizontal and vertical gradients in parallel, sums the absolute values ​​of the corresponding horizontal and vertical gradients to obtain the gradient magnitude, and then obtains the convolved pixel based on the gradient magnitude of each pixel. The convolved pixel is then transmitted to the memory 10 so that the memory 10 can output the target filtered image based on the convolved pixel. This achieves high-speed and stable filtering processing of thousands of frames of images, saves FPGA hardware resources, reduces hardware costs, and can be adapted to various FPGA models, improving versatility and portability.

[0043] It should be noted that by selecting the access layered parallel sorting module 410 or convolution module 420 through the mode switching signal, and sharing the row buffer, address generator 20 and state machine controller 50, FPGA hardware resources are saved, small and medium capacity FPGAs can be deployed, reducing hardware costs, and it can be adapted to various FPGA models, improving versatility and portability.

[0044] In one embodiment, the corresponding Verilog project of this application is synthesized, placed, and routed, then downloaded to the FPGA. The host computer converts the 640×512 grayscale original image into a hex file via Matlab and imports it into memory 10. The filter mode signal is configured, selecting either the hierarchical parallel sorting module 410 or the convolution module 420. The filter start signal is raised, and the hardware automatically completes the entire image pipeline processing. After processing, the output hex file is exported from memory 10, and Matlab reads and plots it, comparing the result with the original image to verify the effect. In another example, the output pixels of the front-end camera can be directly connected to the interface of memory 10 of this application to achieve 1000fps real-time hardware filtering output.

[0045] In one embodiment, such as Figure 5 , Figure 6 and Figure 7 As shown, the original image is a 640×512 grayscale image; the FPGA used is a JFM7K325T model; the system clock is 400MHz (generated by PLL frequency multiplication); the image specifications are 640 columns × 512 rows, 8-bit single-channel grayscale; the memory is 10 bits wide with a width of 32 bits, and can read and write 4 pixels at a time; the filtering module 40 supports 128×128 image filtering. The pipeline buffer module 30 is configured as a row buffer with 3 groups of 32-bit row registers 310, and the shift buffer depth is 640 pixels; the hierarchical parallel sorting module 410 is configured as a five-level hierarchical parallel bubble comparison array with 9 inputs and 8-bit parallel processing; the convolution module 420 is configured to calculate the horizontal and vertical gradients in parallel, with the gradient magnitude output as 8-bit; the state machine controller 50 counts rows from 0 to 399, columns from 0 to 599, and a total pixel count of 240,000.

[0046] The host computer imports a 640×512 grayscale image via Matlab, adds 10% random noise, and exports a hex file stored in memory 10. The FPGA is powered on and reset, raising the filter start signal. Address generator 20 reads the 640×512 grayscale image line by line and sends it to pipeline buffer module 30. The pipeline extracts 128×128 neighboring pixels frame by frame and sends them to hierarchical parallel sorting module 410 to generate median-denoised pixels. Four output pixels are packaged in 32-bit format and written to memory 10. After all pixels are processed, the filtering completion flag is raised, and the target filtered image is exported. The target filtered image shows significantly reduced noise. Timing verification shows that the pipeline has no idle cycles, outputs valid pixels every clock cycle, and has no timing violations.

[0047] For example, in the parameters of the corresponding hex file, the dimensions of an image (one frame) include the image width (the number of pixels arranged vertically), the image height (the number of pixels arranged horizontally), and the image pixel depth. The image pixel depth is the number of bits used by the image pixel to describe color. For 256 levels of grayscale per bit, the pixel depth is 8; for the three primary colors, each color has 256 grayscale levels, resulting in a 256*256*256 array with a depth of 24 (three bytes). The array (W, H) of one frame of a static image is shown in the table below:

[0048] The display storage mapping of the digital image corresponding to the hex file is as follows: the top left corner (0,0) pixel of the image frame is used as the base address of the display storage of the image, and the relative position of the top left corner (from left to right, from top to bottom) is used as the offset. The base address plus the offset is the memory mapping address of the corresponding pixel.

[0049] An array of original images consisting of two-dimensional pixels ,here These are the coordinates of pixels. After image processing using image algorithms, an array of the target filtered image is obtained. : .

[0050] For example, the following table shows a 3×3 pixel template:

[0051] Image processing is the process of transforming the original image... The Z5 value of the target filtered image is obtained by calculating the Z5 value of the original image. This calculation process only involves the original image... , , , , , , and These 8 pixels are used in the calculation; the rest are ignored.

[0052] Its convolution formula is: .

[0053] in, For the target filtered image The numerical values ​​of the coordinates, Corresponding to the original image The numerical values ​​of the coordinates, The convolution coefficients are obtained through differential equations, and the specific values ​​vary depending on the algorithm used. The value of is known.

[0054] This conversion process is A single scan of the original image, from left to right and from top to bottom. For example, the image scanning process is a template. Align with (0,0), here , , , , Points outside the original image area are called boundary points (0,0). For example, templates... Align with (0,1), here , , Points outside the original image area are called boundary points (0,1). For example, templates... Align with (0, W-2), here , , If a point is not within the range of the original image, then (0, W-2) is called a boundary point.

[0055] This process determines the upper boundary of the first row and the lower boundary of the last row of the original image, as well as the left boundary of the first column and the right boundary of the last column. The rest are normal convolutions. The upper and lower boundaries are padded with preset values ​​(such as 0) by a preset software to obtain the upper and lower padded boundaries; the left and right boundaries are padded with preset values ​​(such as 0) by the pipeline buffer module 30 to obtain the left and right padded boundaries.

[0056] For example, the image filter uses the 3×3 pixel template described above. The convolution coefficients are:

[0057] The convolution coefficients for sorting using spatial filtering are expressed as follows: .

[0058] in, An array of the original images to The median after sorting, which is the 5th value after sorting (in descending or ascending order).

[0059] For example, the processing procedure of the convolution module 420 is as follows: assuming a horizontal axis operator array - As shown in the table below:

[0060] .

[0061] Assuming a vertical axis operator array - As shown in the table below:

[0062] Substituting into the convolution formula, we get: .

[0063] Assumption For 178, For 178, For 177, For 179, For 178, For 178, For 179, For 180, The value is 179. Then calculate... The process is as follows: ; ; .

[0064] It should be noted that the above embodiment uses a 128*128 template filter, with an original image size of W*H=640*512 monochrome pixels and a depth of 8 bits. A pipelined architecture is employed to ensure maximum processing efficiency (no idle cycles), with a frame rate of 1000 frames per second. Both the original image and the target filtered image are located in 10 SRAM static memory, with a capacity guaranteeing 640*512 pixels for both the original and target filtered images. The pipeline throughput is one pixel processed per cycle.

[0065] In one embodiment, such as Figure 8 As shown, this application also provides an image processing method applied to the image processing system as described in any of the above claims. The image processing method includes: Step S810: Control the memory to receive the original image, so as to cache the original image in the memory, and control the address generator to read the storage address of the original image in the memory line by line.

[0066] Step S820: Control the pipeline buffer module to obtain the storage addresses of each row read by the address generator, so that the pipeline buffer module reads the pixels of the original image in parallel based on the storage addresses of each row and the preset number of rows, and outputs the neighborhood pixels based on the preset pixel template.

[0067] Step S830: The control filtering operation module receives the neighborhood pixels, performs filtering processing on the neighborhood pixels to obtain filtered pixels, and transmits the filtered pixels to the memory so that the memory outputs the target filtered image based on the filtered pixels.

[0068] For example, the state machine controller controls the memory to receive the original image (such as a 640×512 grayscale image) to cache the original image in the memory, and controls the address generator to read the storage address of the original image in the memory line by line; so that the pipelined cache module obtains the storage address of each line read by the address generator, so that the pipelined cache module reads 32-bit pixels of the original image in parallel cache according to the storage address of each line, based on a preset number of lines (such as three lines), and outputs 9 channels of 8-bit neighborhood pixels based on a preset pixel template (such as a 3×3 pixel template); the state machine controller controls the filtering operation module to receive the 9 channels of 8-bit neighborhood pixels, and performs filtering processing on the 9 channels of 8-bit neighborhood pixels to obtain filtered pixels, and packs the filtered pixels into 32-bit four-pixel format and writes them back to the memory, so that the memory outputs the target filtered image according to the filtered pixels.

[0069] In the above embodiments, by using a memory to cache the original image and building a pipelined cache module and a filtering operation module, it is possible to process thousands of frames of images at high speed and stably. The shared line cache, address generator and state machine controller save FPGA hardware resources, and small and medium capacity FPGAs can be deployed, reducing hardware costs. It can also be adapted to various FPGA models, improving versatility and portability.

[0070] It should be understood that, although Figure 8 The steps in the flowchart are shown sequentially as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order in which these steps are executed, and they can be performed in other orders. Figure 8 At least some of the steps in the process may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least some of the sub-steps or stages of other steps.

[0071] In one embodiment, the steps of controlling the memory to receive the original image for caching, and controlling the address generator to read the storage address of the original image from the memory line by line, are as follows: Perform global reset and memory interface configuration: After power-on, a low-level reset signal rst_n triggers a system-wide synchronous reset, and the state machine enters the reset state; configure the on-chip SRAM as a 32-bit wide, row-first dual-port operating mode, and lock the read / write clock to be from the same source as the global 400MHz clock; clear the base address register, row counter, and column counter inside the address generator, and configure the address step unit to 32 bits; Image storage base address mapping and write channel enable: After reset, the state machine jumps to the image read state and pulls the SRAM write enable signal high; the original image storage base address is written to the address generator, establishing an address mapping rule with the top left pixel (0,0) as the base address and row priority incrementing: the storage address of any pixel coordinate (x,y) = base address + y × image row width in bytes + x; at the same time, the image size parameters (640 columns × 512 rows) are written to the state machine's counter comparison register as the basis for determining whether the write is complete; 32-bit packet writing and row-by-row buffer alignment: Receive the raw image data stream in hex format from external input, and pack four consecutive 8-bit pixels into a single write unit with a 32-bit width. Write the data sequentially to the corresponding address in SRAM row by row. After writing each row of 640 pixels (i.e., 160 32-bit units), the row counter in the state machine automatically increments by 1, the column counter is cleared to zero, and the address generator automatically jumps to the starting address of the next row, achieving seamless writing between rows. During the writing process, the consistency between the number of bytes written in each row and the preset row width is checked in real time. If misalignment occurs, address recalibration is triggered. Perform read / write mode switching and row-by-row read enable: When the row counter reaches 512 (full graph write completed), the state machine pulls down the SRAM write enable and pulls up the read enable to complete the read / write mode switching; a row-by-row read start instruction is sent to the address generator, the read / write address timing logic of the address generator is reused, the row counter is reset to 0, the column counter is reset to 0, and the starting read address of the first row is locked; To achieve progressive address output and pipeline pre-synchronization: the address generator outputs the storage address of the current row in 32-bit increments every clock cycle, continuously reading the pixel data of that row; after outputting all the addresses of a row, the row counter automatically increments by 1, seamlessly jumping to the starting address of the next row, achieving continuous progressive address output without any idle time; at the same time, the state machine controller sends a row data ready pre-trigger signal to the subsequent pipeline buffer module one clock cycle in advance, preloading the parallel buffer control signal and eliminating pipeline start-up interruptions; Address validity verification and state readiness: During address output, the state machine compares the current address offset with the preset image size in real time to verify the validity and continuity of the row address range and prevent out-of-bounds reading; when all addresses of the last row (row 511) are output, the address generator enters the address holding state, and the state machine jumps to the pipeline operation ready state to wait for the read response from the pipeline cache module and complete the entire cache and row-by-row address reading process.

[0072] In one embodiment, the steps of the pipeline buffer module obtaining the storage addresses of each row read by the address generator, so that the pipeline buffer module reads the pixels of the original image in parallel based on the storage addresses of each row and a preset number of rows, and outputs the neighborhood pixels based on a preset pixel template, are as follows: After the state machine enters the pipeline operation state, it sends three consecutive rows of read instructions to the address generator, loading the pixel data of rows 0, 1, and 2 into the three 32-bit row buffers: the front row register, the middle row register, and the back row register, in row order. After all three rows are loaded, the state machine simultaneously pulls up the shift buffer register enable signal and the filter module ready signal, and synchronously starts the shift output and subsequent filtering operations, ensuring that the complete 3×3 neighborhood can be output in the first clock cycle. The 32-bit pixels are unpacked and aligned with the pixels in the row in order: When the 32-bit bus data output from the memory is written to the row register, the hardware automatically splits it into 4 independent 8-bit grayscale pixels in the order of low byte to high byte, corresponding to 4 consecutive pixels in the column address; each row of 640 pixels fills 160 32-bit storage units, arranged in order from left to right according to the column index, to ensure that the pixel space order corresponds one-to-one with the memory address order; Hardware-synchronized filling of left and right boundaries and row data padding: During the same clock cycle when each row of pixels is written to the row register, the boundary processing logic automatically fills the leftmost and rightmost ends of the row with a preset value (0) of 8 bits, forming a row buffer structure with 1 left padding bit, 640 valid pixels and 1 right padding bit; the filling action is completed in parallel with the row data writing. The shift buffer register performs shift operations on a clock cycle and outputs the 3×3 neighborhood pixels in parallel: The shift buffer register is connected to the output of the three row registers, and completes an 8-bit right shift operation once every global clock cycle; after each shift, it simultaneously latches 3 pixels in each corresponding column of the three rows, forming a total of 9 8-bit neighborhood pixels in 3×3 (Z1~Z9, spatially corresponding to top left, top middle, top right, middle left, middle middle, middle right, bottom left, bottom middle, bottom right), which are synchronously output to the filtering operation module; each clock cycle outputs a group of valid neighborhood pixels, corresponding to a center pixel to be processed; Seamless integration of row sliding replacement with pipeline: After the shift register completes the shift output of a whole row of pixels, the hardware automatic row update logic is triggered, discarding the old data in the previous row register; the data in the middle row register is shifted to the previous row register, and the data in the next row register is shifted to the middle row register; the address generator automatically reads the next row of pixel data and writes it to the empty next row register; Upper and lower boundary row recognition and software pre-filling adaptation: The state machine has a built-in row counter that compares the current processing row number in real time. When processing the first row of the image, it automatically recognizes the upper boundary zero value row corresponding to the software pre-filling in the previous row register and directly participates in the shift output. When processing the last row of the image, it automatically recognizes the lower boundary zero value row corresponding to the software pre-filling in the next row register and completes the output of the last row's neighborhood. Full image traversal complete and output state terminated: When the row counter counts to the last row and the column counter counts to the last column, it is confirmed that all neighboring pixels of the full image have been output; the state machine pulls the shift register enable signal low, terminates the output of neighboring pixels, and jumps to the preparation state for writing back the filtering result, and enters the next processing stage.

[0073] In one embodiment, the steps of the step control filtering operation module to receive neighborhood pixels, perform filtering processing on the neighborhood pixels to obtain filtered pixels, and transmit the filtered pixels to the memory so that the memory can output the target filtered image based on the filtered pixels are as follows: Filter mode pre-configuration and computation path synchronous connection are performed: In the first clock cycle before the output of the first group of 3×3 neighborhood pixels in the pipeline buffer module, the state machine completes the hardware path switching according to the externally input filter mode selection signal: the input gate of the hierarchical parallel sorting module or the convolution module is selected, and the internal registers and pipeline flags of the corresponding computation module are reset at the same time; when the first group of neighborhood pixels in the front end arrives at the input end of the computation module, the path is fully ready and directly enters the computation flow; Nine neighborhood pixels (Z1~Z9) are simultaneously input into a 5-level hierarchical parallel bubble comparison array to complete the ascending sort of all pixels; the extraction module directly selects the 5th pixel of the sorted sequence as the median, replaces the neighboring center pixel, obtains the filtered pixel, and latches the output; or; the neighborhood pixels are simultaneously mapped to two independent calculation paths, horizontal and vertical, and Sobel operator weights are loaded in parallel to calculate the horizontal gradient and vertical gradient respectively; the absolute values ​​of the gradients in the two directions are summed to obtain the gradient magnitude, truncated to 8 bits for output, and the edge detection is completed; Filtering result bit width adaptation and 32-bit parallel packing: The 8-bit filtered pixel output in each clock cycle first enters the output buffer register group with a depth of 4; after accumulating the filtering results of 4 consecutive columns, the hardware automatically packs them into a 32-bit data unit according to column order (low byte corresponds to left pixel, high byte corresponds to right pixel) to match the bit width requirements of the memory; the packing action is completely parallel and overlapped with the front-end filtering calculation, the calculation is not interrupted, the packing does not take up extra time, and the entire row of pixels is output as an integer number of 32-bit units; Address-reused row-by-row write-back and memory mapping: The state machine controls the address generator to reuse the same set of address counting logic to generate the write-back address of the target filtered image. The address mapping rules are completely consistent with the original image: row-first storage, base address, row offset, column offset, ensuring that each filtering result corresponds one-to-one with the original pixel; after each 32-bit unit is packaged, it is immediately written to the corresponding address in memory via the write bus. The write-back operation is synchronized with the front-end pipeline calculation; after each row of pixels is filtered and written back, the address generator automatically jumps to the target starting address of the next row. The row sliding step and the write-back address step are completely synchronized. Automatic boundary result filtering and valid area verification: The state machine's built-in row counter and column counter mark the position of the currently processed pixel in real time; for the filtering results corresponding to the upper and lower boundaries (software pre-filled zero value rows) and the left and right boundaries (hardware-filled zero value columns), the hardware automatically marks them as invalid data and does not write them into the valid storage area of ​​the target image; only the filtering results corresponding to the 640×512 valid area of ​​the original image are written into the memory to ensure that the final output image size is completely consistent with the original image; Full image processing complete and target image output enabled: When the row counter and column counter have counted all pixels and all filtering results have been written back, the state machine automatically jumps to the completion state and pulls up the externally visible filtering completion flag; the memory automatically switches to read output mode, and the target filtered image can be read line by line through the external bus, or directly output to subsequent image acquisition and display devices.

[0074] In one embodiment, this application also provides a processing device, including an image acquisition module and an image processing system as described in any of the above; the image acquisition module is connected to the image processing system.

[0075] For example, the processing device can be, but is not limited to, image processing devices such as airborne optoelectronic devices, industrial vision devices, and security monitoring devices. The image acquisition module can be a camera, which is used to acquire raw images. For a detailed description of the image processing system, please refer to the descriptions of the image processing system in the above embodiments; they will not be repeated here.

[0076] For example, an image processing system includes a memory, an address generator, a pipelined buffer module, a filtering operation module, and a state machine controller. The image acquisition module is connected to the memory and the state machine controller; the address generator is connected to the memory; the pipelined buffer module is connected to the address generator and the memory; the filtering operation module is connected to the pipelined buffer module and the memory; and the state machine controller is connected to the memory, the address generator, the pipelined buffer module, and the filtering operation module. The state machine controller controls the memory to receive the raw image transmitted from the image acquisition module, buffering the raw image in the memory, and controls the address generator to read the storage address of the raw image from the memory line by line. The state machine controller controls the pipelined buffer module to obtain the address read by the address generator. The system uses the storage addresses of each row to enable the pipelined buffer module to read pixels from the original image in parallel based on the preset number of rows and cache them in parallel. It also outputs neighborhood pixels based on a preset pixel template. The state machine controller controls the filtering module to receive neighborhood pixels, perform filtering on them, and obtain filtered pixels. These filtered pixels are then transferred to the memory, allowing the memory to output the target filtered image based on the filtered pixels. This enables high-speed parallel filtering of grayscale images at the thousand-frame level. The shared row buffer, address generator, and state machine controller save FPGA hardware resources, allowing deployment with small to medium-capacity FPGAs, reducing hardware costs, and providing compatibility with various FPGA models, thus improving versatility and portability.

[0077] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above 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.

[0078] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the patent application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this patent application should be determined by the appended claims.

Claims

1. An image processing system, characterized in that it comprises: Memory; An address generator, the address generator being connected to the memory; A pipelined cache module, wherein the pipelined cache module is connected to the address generator and the memory; A filtering operation module, wherein the filtering operation module is connected to the pipeline buffer module and the memory; A state machine controller is connected to the memory, the address generator, the pipelined buffer module, and the filtering operation module, respectively. The state machine controller is used to control the memory to receive the original image so as to cache the original image through the memory, and to control the address generator to read the storage address of the original image in the memory line by line; The state machine controller is also used to control the pipelined cache module to obtain the storage addresses of each row read by the address generator, so that the pipelined cache module reads the pixels of the original image in parallel based on the storage addresses of each row and a preset number of rows, and outputs the neighborhood pixels based on the preset pixel template. The state machine controller is also used to control the filtering operation module to receive the neighborhood pixels, perform filtering processing on the neighborhood pixels to obtain filtered pixels, and transmit the filtered pixels to the memory so that the memory outputs the target filtered image based on the filtered pixels.

2. The image processing system according to claim 1, characterized in that the pipelined buffer module is used to perform boundary recognition on the pixels of the parallel-buffered original image to obtain each boundary pixel point, and to fill each of the boundary pixel points with a preset value to obtain a target buffer pixel sequence; the pipelined buffer module is further used to output the target buffer pixel sequence based on a preset pixel template to obtain the neighborhood pixels.

3. The image processing system according to claim 2, wherein the target cache pixel sequence includes an upper padding boundary, a lower padding boundary, a left padding boundary, and a right padding boundary; The upper and lower fill boundaries are obtained by filling with preset values ​​using preset software; the left and right fill boundaries are obtained by filling with preset values ​​using the pipeline buffer module.

4. The image processing system according to claim 1, characterized in that the pipelined buffer module includes multiple sets of row registers and shift buffer registers; the shift buffer registers are connected to each set of row registers; The row register is used to cache the corresponding row pixels of the original image based on the storage address of the corresponding row; the shift buffer register is used to obtain the corresponding number of pixels cached by each row register based on a preset pixel template, and obtain the neighborhood pixels.

5. The image processing system according to claim 1, wherein the filtering operation module includes a hierarchical parallel sorting module; The hierarchical parallel sorting module is connected to the pipeline cache module, the state machine controller, and the memory; The state machine controller is used to control the hierarchical parallel sorting module to receive the neighborhood pixels, so that the hierarchical parallel sorting module performs pixel sorting processing on the neighborhood pixels to obtain sorted pixels, performs median filtering processing on the sorted pixels to obtain filtered pixels, and transmits the filtered pixels to the memory, so that the memory outputs the target filtered image based on the filtered pixels.

6. The image processing system according to claim 5, characterized in that the hierarchical parallel sorting module includes a multi-level comparator and an extraction module, the multi-level comparator being connected to the state machine controller and the pipeline buffer module; the extraction module being connected to the multi-level comparator and the memory; The multi-level comparator is used to compare the pixel values ​​of the input neighborhood pixels and sort the pixels of the neighborhood pixels based on the pixel values ​​to obtain sorted pixels. The extraction module is used to extract the median of the sorted pixels to obtain the median of the pixels, and update the center pixel value of the neighborhood pixels to the median of the pixels to obtain the filtered pixels.

7. The image processing system according to claim 1, wherein the filtering operation module further includes a convolution module; The convolution module is connected to the pipeline cache module, the memory, and the state machine controller; The state machine controller is also used to control the convolution module to acquire the neighborhood pixels, perform convolution processing on the neighborhood pixels to obtain convolutional pixels, and transmit the convolutional pixels to the memory so that the memory outputs the target filtered image based on the convolutional pixels.

8. The image processing system according to claim 7, characterized in that the convolution module is used to perform horizontal and vertical gradient processing on the neighborhood pixels to obtain each horizontal gradient value and each vertical gradient value, and to perform absolute value summation processing on the corresponding horizontal gradient value and the corresponding vertical gradient value to obtain the gradient magnitude of the corresponding pixel, and to obtain the convolved pixel based on the gradient magnitude of each pixel.

9. An image processing method characterized by, Applied to the image processing system as described in any one of claims 1 to 8, the method comprises: The control memory receives the original image to cache the original image through the memory, and the control address generator reads the storage address of the original image in the memory line by line; The pipeline buffer module is controlled to obtain the storage addresses of each row read by the address generator, so that the pipeline buffer module reads the pixels of the original image in parallel based on the storage addresses of each row and a preset number of rows, and outputs the neighborhood pixels based on the preset pixel template. The control filtering operation module receives the neighborhood pixels, performs filtering processing on the neighborhood pixels to obtain filtered pixels, and transmits the filtered pixels to the memory so that the memory outputs the target filtered image based on the filtered pixels.

10. A processing apparatus, characterized in that, It includes an image acquisition module and an image processing system as described in any one of claims 1 to 8; the image acquisition module is connected to the image processing system.