CN101567080B - An infrared focal plane array image enhancement method - Google Patents

Abstract

The invention discloses a method for strengthening an infrared focal plane array image, pertains to the field of infrared focal plane detector, particularly relates to the hardware realization of a specified image processing algorithm, and aims at extending image gray value and increasing computerization speed under the condition of limited FPGA storage resource. The method comprises the steps of median filtering, sub-point access and sub-section extension. The median filter adopted by the method eliminates spiced salt noise in the image and the sub-section extension effectively strengthens the detailed part of the dark image area. The algorithm requires no external memory, has low requirement for the FPGA storage resource and good real-time property and can effectively fit the high requirement of the infrared focal plane detector to image strengthening processing.

Description

An infrared focal plane array image enhancement method

technical field

The invention belongs to the field of infrared focal plane detectors, in particular to an infrared focal plane array image enhancement method.

Background technique

Infrared imaging systems have evolved with the development of infrared detectors. In the first-generation infrared imaging system, linear detectors are used to realize imaging through one-dimensional optical-mechanical scanning. With the maturity of CCD (Charge Coupled Device, electrically coupled device) related technologies, in the mid-1970s, the appearance of IRFPA (Infrared Focal Plane Array, infrared focal plane array) detector marked the second generation of infrared imaging system - staring The birth of the infrared imaging system. Compared with linear detectors, focal plane detector imaging has the advantages of high spatial resolution, strong detection capability, and high frame rate, and is rapidly becoming the mainstream device of infrared imaging technology. At present, the staring infrared imaging system has begun to be widely used in civilian fields such as night vision, maritime rescue search, astronomy, industrial heat detection and medicine, and is the development direction of infrared imaging systems. However, due to the reasons of manufacturing materials, technology and working environment, the images output by infrared focal plane array generally have disadvantages such as weak target contrast and blurred background details. For example, the nominal output data width of a certain infrared focal plane array is 16 bits. However, in actual use, no matter what the scene is, most of the pixel values are concentrated in the range from 0x7EC0 to 0x82C0, and the display effect is self-evident. Therefore, it is very necessary to preprocess the image output from the infrared focal plane array to make it suitable for specific applications. The method of image enhancement is divided into two types: air domain method and frequency domain method. The space domain method mainly operates on each pixel in the image; while the frequency domain method operates on the image in a certain transformation domain of the image, and modifies the image after transformation. The coefficients, and then inverse transform to get the processed image.

The frequency domain method regards the image as a two-dimensional signal and transforms it from the time domain to the frequency domain. Using low-pass filtering (that is, only allowing low-frequency signals to pass) can remove the noise in the picture; using high-pass filtering can enhance high-frequency signals such as edges and make blurred pictures clear. However, using a DSP processor to perform forward and reverse transformation of an image in the frequency domain requires a large amount of calculation, and it is difficult to be suitable for occasions with high real-time requirements. The frequency domain method enhances the image in the frequency domain, regardless of high-pass filtering or low-pass filtering, will destroy the original image to a large extent, and a lot of effective information may be filtered out. The calculation of the frequency domain method is complex, and it is difficult to realize it by FPGA, so the frequency domain method has its limitations when applied to high real-time occasions.

Histogram equalization is a typical image enhancement method in the spatial domain. The central idea of histogram equalization processing is to change the gray histogram of the original image from a relatively concentrated gray-scale interval to a gray-scale range. Evenly distributed. The gray value r of the original image is normalized between 0 and 1, and p(r) is the probability density function of the gray distribution of the original image. Histogram equalization processing is actually to find a grayscale transformation function T, so that the changed grayscale value s=T(r), where s is normalized to 0~1, that is, the mapping between r and s is established The relationship requires that the probability density function p(s)=1 of the gray distribution of the processed image, and it is expected that all gray levels have the same probability of occurrence.

For the case of discrete digital images, the calculation steps of histogram equalization processing are as follows:

(1) Statistical histogram of the original image

${\mathrm{<span\; class="notranslate">\; p</span>}}_{\mathrm{<span\; class="notranslate">\; r</span>}}<span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; r</span>}}_{\mathrm{<span\; class="notranslate">\; k</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>\frac{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; k</span>}}}{\mathrm{<span\; class="notranslate">\; no</span>}}$

where r _k is the normalized grayscale of the input image, _nk is the number of pixels in the input image whose normalized grayscale is equal to r _k , and n is the total number of pixels in the input image.

(2) Calculate the histogram cumulative distribution curve

${\mathrm{<span\; class="notranslate">\; S</span>}}_{\mathrm{<span\; class="notranslate">\; k</span>}}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; T</span>}<span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; r</span>}}_{\mathrm{<span\; class="notranslate">\; k</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>\underset{\mathrm{<span\; class="notranslate">\; j</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}}{\overset{\mathrm{<span\; class="notranslate">\; k</span>}}{\mathrm{<span\; class="notranslate">\; \&Sigma;</span>}}}{\mathrm{<span\; class="notranslate">\; p</span>}}_{\mathrm{<span\; class="notranslate">\; r</span>}}<span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; r</span>}}_{\mathrm{<span\; class="notranslate">\; j</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>\underset{\mathrm{<span\; class="notranslate">\; j</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}}{\overset{\mathrm{<span\; class="notranslate">\; k</span>}}{\mathrm{<span\; class="notranslate">\; \&Sigma;</span>}}}\frac{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; j</span>}}}{\mathrm{<span\; class="notranslate">\; no</span>}}$

(3) Use the cumulative distribution function as the transformation function to perform image grayscale transformation

According to the calculated cumulative distribution function, the corresponding relationship between the input image and the output image gray level is established, and finally the transformed gray level is restored to the original range.

As a basic image processing method, histogram equalization has been applied in many fields, but most of them are realized by DSP or CPU programming. Its advantages are high flexibility and convenient debugging. The biggest disadvantage is that it is difficult to achieve real-time or quasi-real-time processing, which is unacceptable in some areas. The use of FPGA can solve the problem of real-time processing very well. However, histogram statistics usually require a storage space of about a whole image, such as the article "FPGA Realization of Histogram Equalization of Video Image Gray Signal Signal" in "Application of Electronic Technology" No. 11, 2006. The advantage is that histogram equalization It can play a good role in image enhancement. The disadvantage is that it does not solve the problem that histogram statistics need to consume a lot of storage resources. It simply expands a piece of SDRAM outside the FPGA for histogram statistics, which increases the cost and reduces the cost. system integration.

"Microcomputer Information", Volume 63, Issue 6-2, 2007 "FPGA-based Real-time Infrared Image Linear Enhancement Algorithm", uses 5 frames of images to iterate between frames to obtain the maximum and minimum values in the image , perform a linear stretch. Its advantage is that it does not need to cache the entire image and has low requirements for storage resources. However, its inter-frame iteration algorithm is inefficient and can only obtain the maximum and minimum values in the image, and the stretching flexibility is very low.

Contents of the invention

The purpose of the present invention is to provide an infrared focal plane array image enhancement method, which can effectively enhance the details of the dark area of the image under the condition of limited FPGA resources, and improve the operation speed.

Infrared focal plane array image enhancement method provided by the present invention, its steps include:

Step 1 Median filtering

Perform median filtering on the image of the nth frame, where n is the frame number of the image to be processed;

Step 2 Segmentation point acquisition

Use the following formulas (I), (II) and formula (III) to calculate the minimum gray value X _min ⁿ , the maximum gray value X _max ⁿ and the gray value of the segmentation point of the nth frame image after median filtering X _b ⁿ ;

$\left\{\begin{array}{c}{x}_{\min }^{\mathrm{no}}=x_{\min }^{\mathrm{no}-1}+{\mathrm{step}}_{\min }^{\mathrm{no}}\\ {\mathrm{step}}_{\min }^{\mathrm{no}}=K_{\min }^{\mathrm{no}}*\mathrm{\&Delta;X}\\ K_{\min }^{\mathrm{no}}=m*N*\min \%-\min \_{\mathrm{counter}}^{\mathrm{no}}\end{array}\right.$ Formula (I)

$\left\{\begin{array}{c}{x}_{\max }^{\mathrm{no}}=x_{\max }^{\mathrm{no}-1}+{\mathrm{step}}_{\max }^{\mathrm{no}}\\ {\mathrm{step}}_{\max }^{\mathrm{no}}=K_{\max }^{\mathrm{no}}*\mathrm{\&Delta;X}\\ K_{\max }^{\mathrm{no}}=m*N*\max \%-\max \_{\mathrm{counter}}^{\mathrm{no}}\end{array}\right.$ Formula (II)

$\left\{\begin{array}{c}{x}_b^{\mathrm{no}}=x_b^{\mathrm{no}-1}+{\mathrm{step}}_b^{\mathrm{no}}\\ {\mathrm{step}}_b^{\mathrm{no}}=K_b^{\mathrm{no}}*\mathrm{\&Delta;X}\\ K_b^{\mathrm{no}}=m*N*b\%-b\_{\mathrm{counter}}^{\mathrm{no}}\end{array}\right.$ Formula (III)

X _min ^n-1 , X _max ^n-1 and X _b ^n-1 are the minimum gray value, the maximum gray value and the gray value of the segmentation point of the n-1th frame image respectively, and M*N is the nth The resolution of the frame image, min%, max%, and b% respectively represent the user-set ratio values, which represent the minimum gray value, maximum gray value, and gray value of the segmentation point in the actual image that are smaller than those in the stretching algorithm The proportion of pixels in the total pixels; min_counter ⁿ , max_counter ⁿ and b_counter ⁿ are the number of pixels whose gray value is less than X _min ^n-1 , X _max ^n-1 and X _b ^n-1 in the nth frame image respectively, ΔX is the iteration weight;

Step 3 segmented stretch

Use the X _min ⁿ , X _max ⁿ and X _b ⁿ obtained in the second iteration to stretch the image of the n+1th frame, and the output gray value X _out ⁿ⁺¹ after stretching the n+1th frame of the image in sections:

${\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; out</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}\mathrm{<span\; class="notranslate">\; 0</span>}& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 1</span>}<span\; class="notranslate">\; *</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; /</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span>& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 2</span>}<span\; class="notranslate">\; *</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; /</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span>& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 1</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 2</span>}& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; ></span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\end{array}\right.$

Among them, X _in ⁿ⁺¹ is the original gray level of the input image of frame n+1, S1 is the gray level assigned to [X _min ⁿ , X _b ⁿ ], and S2 is the gray level assigned to [X _b ⁿ , X _max ⁿ ] The gray level, S1 and S2 are set by the user, and S1+S2 is the gray level that the user needs to stretch to.

The above-mentioned median filtering process is preferably a fast median filtering algorithm. The algorithm first sorts the three-column elements of a 3*3 window; then sorts the three-row elements of the column-sorted window; and finally calculates the three elements on the diagonal. The median value, the resulting median value is the median value of the 9 elements.

On the basis of the background technology, the present invention divides the image into bright objects and dark areas, and stretches them separately, which effectively enhances the details of the large-area dark areas of the image, and suppresses the effect of small-area bright objects on the effect of the stretching algorithm. Influence. A frame-to-frame iterative algorithm based on the idea of negative feedback was developed to quickly and stably obtain the segmentation points of each segment. The w-bit digital image output by the infrared focal plane array is quantized to k-bit to make it easy to process. Usually w=16 or 14, and the value of k is selected by the user, usually 8 bits. This algorithm can be completely implemented independently by FPGA without the cooperation of external memory and DSP. Specifically, the inventive method has the following technical characteristics:

(1) There is no need to cache the entire image in all steps of the method of the present invention, so the present invention greatly reduces the requirement of the algorithm for storage resources. Because of the IC manufacturing process, the built-in large-capacity storage resources in the chip will increase the manufacturing cost of the chip. The low memory consumption feature of the present invention makes it possible to be integrated in a SOC system as an IP core at a lower cost. If the present invention is realized in FPGA, the resource consumption is low, the realization cost is greatly reduced, and the integration degree of the system is improved.

(2) In the step of segment point acquisition, there is no need to cache the image, and the iterative operation can be completed while the image is input. Taking the acquisition of X _min ⁿ as an example, ^the selection of the iterative step size V ⁿ is based on the idea of negative feedback, the step size is variable _, and the step size is large at the beginning of the iteration. To achieve high iteration accuracy, generally after 10 frames of images, X _min ⁿ , X _max ⁿ , and X _b ⁿ can tend to be stable. The iterative operations of X _min ⁿ , X _max ⁿ , and X _b ⁿ make full use of the characteristics of FPGA parallel operation and execute them simultaneously, which greatly improves the efficiency of algorithm operation.

(3) Segmented stretching can stretch the image to any gray level. At present, the output of infrared focal plane array images is mostly 16 bits, but for most target detection and tracking algorithms, only 8-bit grayscale images are required.

(4) In the segmental stretching step, considering that the salt and pepper noise of the infrared focal plane is relatively bad, the median filter may not filter out all the salt and pepper noise, and the segmental stretching selects min% and max at both ends of the histogram The gray value at % is used as the maximum gray value X _max and the minimum gray value X _min of the image, so that the maximum and minimum values of the stable image can be obtained, which provides stable parameters for the image enhancement algorithm. Generally, min takes 1~3, and max takes 97~99.

(5) In the segmented stretching step, the image is divided into bright objects and dark areas by using the method of stretching in two segments, and stretched separately, which effectively enhances the details of the large dark area of the image and suppresses the The influence of small area bright objects on the effect of stretching algorithm.

The preferred fast median filtering algorithm of the present invention only needs three clock cycles to obtain the median value, which greatly improves the speed. This algorithm does not reduce the number of sorting times. In the first two clock cycles, the three three-input sorters need to sort three times, and finally obtain the median value and need 21 sorting times. But the comparison of the three three-input sequencers is performed simultaneously in the first two clock cycles. This algorithm adopts the method of exchanging area for speed, and maximizes the parallel capability of FPGA, so its speed improvement is also the largest.

Description of drawings

Fig. 1 is a flow chart of the inventive method;

Fig. 2 is a square window and median filtering algorithm flow chart;

Fig. 3 is a state transition diagram of the segmentation point acquisition step;

Fig. 4 is the timing sequence of digital image output by thermal imager;

Figure 5 is the original picture;

Figure 6 is the enhanced image.

Detailed ways

The invention divides the image into bright objects and dark areas, and stretches them separately, effectively enhancing the details of the large-area dark areas of the image, and suppressing the influence of small-area bright objects on the effect of the stretching algorithm.

The key of the present invention is to obtain the three grayscale values of the nth frame image, i.e. the minimum grayscale value X _min ⁿ of the frame image, the maximum grayscale value X _max ⁿ and the grayscale value X _b ⁿ of the segmentation point, using For stretching the n+1th frame image, n is the frame number of the image, and the image resolution size is M*N.

The number of pixels whose gray value is less than X _min ⁿ accounts for min% of the total number of image pixels, that is, M*N*min%;

The number of pixels whose grayscale value is less than X _max ⁿ accounts for max% of the total number of image pixels, that is, M*N*max%;

The number of pixels whose gray value is less than X _b ⁿ accounts for b% of the total number of image pixels, that is, M*N*b%;

The values of min, max and b are preset by the user. Generally speaking, the range of min is 1-3, max is 97-99, and b is set according to the estimated ratio of bright objects to the image area. In this way, pixels with a gray value smaller than X _b ⁿ are considered to be large-area dark areas, and more gray levels are allocated; pixels with gray values greater than X _b ⁿ are considered to be small-area bright objects, and less gray is allocated. degree level.

The steps of the present invention are described in detail below:

The infrared focal plane array image enhancement method provided by the present invention includes median filtering, segmental point acquisition, and segmental stretching.

(1) Median filtering

Median filtering can preferably be performed in the following manner: 3*3 square window as shown in Figure 2, use mid{I1, I2, I3, I4, I5, I6, I7, I8, I9} to replace the middle position of the original square window raw pixel value. Afterwards, whenever a pixel and its neighboring pixels are processed by the median filter, the 3*3 square window will continuously move to the right or wrap until all the pixels in the data array of a grayscale image are processed.

Median filtering algorithm in a square window: first sort the elements of the three columns of a 3*3 window; then sort the elements of the three rows of the window after the columns are sorted; finally find the median of the three elements on the diagonal, and obtain the median The value is the median of the 9 elements.

(2) Segment point acquisition

The acquisition of X _min ⁿ , X _max ⁿ and X _b ⁿ (segmentation points) adopts an iterative method frame by frame. Take the acquisition of X _min ⁿ as an example. X _min ⁰ is the initial value of X _min ⁿ . The nominal output data width of the infrared focal plane array is 16 bits. However, in actual use, no matter what the scene is, most pixel values Concentrated on the range from 0x7EC0 to 0x82C0, so let $x_{\min }^0=0x7\mathrm{EC}0;$

Register min_counter ⁿ records the number of pixels whose gray value is less than X _min ^n-1 in the nth frame of the image, and ΔX is the iteration weight. The larger ΔX is, the higher the iteration speed is, but the accuracy becomes lower. It is a trade-off between iteration accuracy and iteration efficiency. , generally can be set to 1.

Use the following formula to loop and iterate,

${\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; +</span>{\mathrm{<span\; class="notranslate">\; step</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}$

${\mathrm{<span\; class="notranslate">\; step</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; K</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; *</span>\mathrm{<span\; class="notranslate">\; \&Delta;X</span>}$

${\mathrm{<span\; class="notranslate">\; K</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; m</span>}<span\; class="notranslate">\; *</span>\mathrm{<span\; class="notranslate">\; N</span>}<span\; class="notranslate">\; *</span>\mathrm{<span\; class="notranslate">\; min</span>}<span\; class="notranslate">\; \%</span><span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; min</span>}<span\; class="notranslate">\; \_</span>{\mathrm{<span\; class="notranslate">\; counter</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}$

Register max_counter ⁿ records the number of pixels whose gray value is less than X _max ^n-1 in the nth frame image,

Register b_counter ⁿ records the number of pixels whose gray value is less than X _b ^n-1 in the nth frame image,

X _max ⁿ and X _b ⁿ are obtained in the same way. Generally, after 10 frames of images, X _min ⁿ , X _max ⁿ and X _b ⁿ tend to be stable.

(3) Sectional stretching

Two-stage stretching method, where X _in ⁿ⁺¹ is the original grayscale of the input image of frame n+1, X _out ⁿ⁺¹ is the grayscale output after stretching the image of frame n+1 in segments, and S1 is The gray level assigned to [X _min ⁿ , X _b ⁿ ], S2 is the gray level assigned to [X _b ⁿ , X _max ⁿ ]. In this embodiment, the 16-bit image is stretched to 8-bit grayscale, so S1+S2=255; S1=200, S2=55;

Use the X _min ⁿ , X _max ⁿ and X _b ⁿ obtained from the previous n frame iterations to stretch the image of the n+1th frame. The transformation formula is:

${\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; out</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}\mathrm{<span\; class="notranslate">\; 0</span>}& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 1</span>}<span\; class="notranslate">\; *</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; /</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span>& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 2</span>}<span\; class="notranslate">\; *</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; /</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span>& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 1</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 2</span>}& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; ></span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\end{array}\right.$

The present invention is described in more detail below by means of examples, but the following examples are only illustrative, and the protection scope of the present invention is not limited by these examples.

The invention processes the real-time output image of a cooling type focal plane, the image format size is: 320*256, the frame frequency is 50 frames per second, the pixel data bit width is 16 bits, the scene is an outdoor building, and the focal plane output image sequence As shown in Figure 4.

The steps of the present invention are described in detail below:

(1) Median filtering

Generate two dual-port RAMs, DPRAM0 and DPRAM1, in the FPGA. Each dual-port RAM is used to cache 3 lines of data, and its size is just enough to cache 3 lines of data. Using the method of ping-pong operation, one dual-port RAM performs median filtering, and the other dual-port RAM stores the focal plane output. image data. The process of the median filtering algorithm is shown in Figure 2. First, sort the three-column elements of a 3*3 window; then sort the three-row elements of the column-sorted window; and finally find the median of the three elements on the diagonal , the resulting median is the median of the 9 elements. After the image enters this module, the median filter result will be output after 320+3 pixel clocks. By delaying the effective frame signal by 320+3 pixel clock cycles, the median filter module can output the median filter result map in the focal plane sequence.

(2) Segment point acquisition

The acquisition of X _min ⁿ , X _max ⁿ and X _b ⁿ (segmentation points) adopts an iterative method frame by frame. Take the acquisition of X _min ⁿ as an example, X _min ⁰ is the initial value of X _min ⁿ , the register min_counter ⁿ records the number of pixels whose gray value is less than X _min ^n-1 in the image of the nth frame, and ΔX is the iteration weight . In this example, min=1, max=99, b=80, ΔX=1;

Use the following formula to loop and iterate,

${\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; +</span>{\mathrm{<span\; class="notranslate">\; step</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}$

${\mathrm{<span\; class="notranslate">\; step</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; K</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; *</span>\mathrm{<span\; class="notranslate">\; \&Delta;X</span>}$

${\mathrm{<span\; class="notranslate">\; K</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; m</span>}<span\; class="notranslate">\; *</span>\mathrm{<span\; class="notranslate">\; N</span>}<span\; class="notranslate">\; *</span>\mathrm{<span\; class="notranslate">\; min</span>}<span\; class="notranslate">\; \%</span><span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; min</span>}<span\; class="notranslate">\; \_</span>{\mathrm{<span\; class="notranslate">\; counter</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}$

Register max_counter ⁿ records the number of pixels whose gray value is less than X _max ^n-1 in the nth frame image,

Register b_counter ⁿ records the number of pixels whose gray value is less than X _b ^n-1 in the nth frame image,

X _max ⁿ and X _b ⁿ are obtained in the same way. Generally, after 10 frames of images, X _min ⁿ , X _max ⁿ and X _b ⁿ tend to be stable.

When the frame signal is valid, a judgment is made every time a pixel is received.

If the gray value of the pixel is less than X _min ^n-1 , add one to min_counter ⁿ ;

If the pixel gray value is less than X _max ^n-1 , add one to max_counter ⁿ ;

If the gray value of the pixel is less than X _b ^n-1 , add one to b_counter ⁿ ;

After a frame of image is transmitted, min_counter ⁿ , max_counter ⁿ , b_counter ⁿ record the number of pixels whose gray value is less than X _min ^n-1 , X _max ^n-1 , and X _b ^{n-1 in} the nth frame of image.

Then complete the iterative operation in a state machine way.

A finite state machine (FSM) is a simple mathematical model with a finite set of discrete inputs. Instead of having a finite set of states determined by the order in which inputs are received, a finite state machine can have a finite set of outputs. If so, the state machine will produce a sequence of outputs reflecting the sequence of inputs.

Define a finite state machine (FSM) as a five-tuple: M={I, O, S, δ, λ}, I is a finite non-empty set of inputs (input can be a vector); O is a finite non-empty output Set (the output can be a vector); S is a finite non-empty set of states; δ: S×I→S is a state transition function (State TransitionFunction); λ: S×I→O is an output function (Output Fuction). At any moment, the state machine is always in a certain state. When the input enters, the state machine is converted to another state by the state transition function.

Contrasting the quintuple of a state machine, the present invention designs a template parameter programming state machine with the way of determining quintuple, and its state transition diagram is as Figure 3, wherein:

TS ₀ is the initial state, TS ₁ is the statistical image state, TS ₂ is the calculation step coefficient (K _min ⁿ K _max ⁿ K _b ⁿ ) state, and TS ₃ is the calculation step size (Step _min ⁿ Step _max ⁿ Step _b ⁿ ) state, and TS ₄ is the state of calculating the segmentation point (X _min ⁿ X _max ⁿ X _b ⁿ ). The initial state is TS ₀ , this state machine

The input is: reset signal, frame valid signal, min_counter ⁿ , max_counter ⁿ , b_counter ⁿ ;

The output is: X _min ⁿ , X _max ⁿ , the values of X _b ⁿ segmentation points;

The output function is: calculate and output the value of the segmentation point;

TS ₀ state: After the system logic is reset, the state is TS ₀ , X _min ⁰ , X _max ⁰ take the initial value closer to the expected value, X _b ⁰ takes (X _min ⁰ +X _max ⁰ )/2; the reset ends and the frame signal Jump to TS ₁ state after valid;

TS ₁ state: Count the number of pixels whose gray value is less than X _min ^n-1 , X _max ^n-1 , and X _b ^n-1 in the image of the nth frame, and record them in min_counter ⁿ , max_counter ⁿ , and b_counter ⁿ respectively. When the frame signal is invalid, jump to TS ₂ state;

TS ₂ state: Calculate the step size coefficient (K _min ⁿ K _max ⁿ K _b ⁿ ), and jump to TS ₃ state after the calculation is completed;

TS ₃ state: Calculate the step size (Step _min ⁿ Step _max ⁿ Step _b ⁿ ), jump to TS ₄ state after the calculation is completed;

TS ₄ state: iteration segmentation point (X _min ⁿ X _max ⁿ X _b ⁿ ), jump to TS ₅ state after the calculation is completed;

TS ₅ state: idle state, output the value of segment point (X _min ⁿ X _max ⁿ X _b ⁿ ), when the frame signal is valid, jump to TS ₁ state;

In this way, the segment point acquisition step will be carried out stably under the control of the internal state machine. When the frame signal is valid, count the image characteristics in TS ₁ state; when the frame signal is invalid: iterate the segmentation points in TS ₂ state, TS ₃ state, and TS ₄ state to complete the iteration. In the TS ₅ state, output the value of the segmentation point (X _min ⁿ X _max ⁿ X _b ⁿ ) and wait for the next iteration.

(3) Sectional stretching

Two-stage stretching method, where X _in ⁿ⁺¹ is the original grayscale of the input image of frame n+1, X _out ⁿ⁺¹ is the grayscale output after stretching the image of frame n+1 in segments, and S1 is The gray level assigned to [X _min ⁿ , X _b ⁿ ], S2 is the gray level assigned to [X _b ⁿ , X _max ⁿ ]. Let S1=200, S2=55. Quantize the 16-bit raw image to 8-bit.

Use the X _min ⁿ , X _max ⁿ and X _b ⁿ obtained from the previous n frame iterations to stretch the image of the n+1th frame. The conversion formula is:

${\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; out</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}\mathrm{<span\; class="notranslate">\; 0</span>}& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 1</span>}<span\; class="notranslate">\; *</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; /</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span>& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; min</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 2</span>}<span\; class="notranslate">\; *</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; /</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; -</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; )</span>& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; b</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; <</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\\ \mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 1</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; S</span>}\mathrm{<span\; class="notranslate">\; 2</span>}& <span\; class="notranslate">\; \&ForAll;</span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; in</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; ></span>{\mathrm{<span\; class="notranslate">\; x</span>}}_{\mathrm{<span\; class="notranslate">\; max</span>}}^{\mathrm{<span\; class="notranslate">\; no</span>}}\end{array}\right.$

Table 1 shows the comprehensive performance comparison of the histogram equalization method, the linear stretching method and the method of the present invention. Set the image size to 320*256, and the pixel bit width to 16bits;

Table 1 Comprehensive comparison of three algorithms

comparison index Histogram equalization method One segment linear stretching method The method of the present invention consume storage resources 65536*17bits＝1,114,112bits none 6*320*16bits＝30720bits Stretch flexibility very good very low better

Salt and pepper noise filtering none none better

Considering the three stretching algorithms implemented in the FPGA, histogram equalization can achieve a good stretching effect, but the storage resources consumed are too high, and a linear stretching solves the problem of excessive storage resource consumption. , but due to the low efficiency of its iterative algorithm, it can only obtain the maximum and minimum values of the image and perform a linear stretch. The method of the present invention inherits the characteristics of a section of linear stretching and low storage resource consumption, performs segmented stretching, and develops an inter-frame iterative algorithm based on the idea of negative feedback, quickly and stably obtains the segmentation points of each segment, and achieves better results. Image enhancement effect.

Claims (2)

1. method for strengthening infrared focal plane array image, its step comprises:

The 1st step, medium filtering:

The n two field picture is carried out medium filtering, and n is the frame number of pending image;

In the 2nd step, waypoint obtains:

Utilize following formula (I), (II) and formula (III) to calculate the minimum gradation value of the n two field picture of process medium filtering respectively Maximum gradation value

Gray-scale value with waypoint

$\left\{\begin{array}{c}{X}_{\min }^n=X_{\min }^{n-1}+{\mathrm{Step}}_{\min }^n\\ {\mathrm{Step}}_{\min }^n=K_{\min }^n*\mathrm{\&Delta;X}\\ K_{\min }^n=M*N*\min \%-\min \_\mathrm{counte}{r}^n\end{array}\right.$ Formula (I)

$\left\{\begin{array}{c}{X}_{\max }^n=X_{\max }^{n-1}+{\mathrm{Step}}_{\max }^n\\ {\mathrm{Step}}_{\max }^n=K_{\max }^n*\mathrm{\&Delta;X}\\ K_{\max }^n=M*N*\max \%-\max \_\mathrm{counte}{r}^n\end{array}\right.$ Formula (II)

$\left\{\begin{array}{c}{X}_b^n=X_b^{n-1}+{\mathrm{Step}}_b^n\\ {\mathrm{Step}}_b^n=K_b^n*\mathrm{\&Delta;X}\\ K_b^n=M*N*b\%-b\_\mathrm{counte}{r}^n\end{array}\right.$ Formula (III)

With

Be respectively the gray-scale value of minimum gradation value, maximum gradation value and the waypoint of n-1 two field picture, M*N is the resolution of n two field picture, min%, max% and b% represent respectively in the n two field picture gray-scale value less than

With Number of pixels account for the ratio of total number of pixels, wherein, the value of min and max and b is preestablished by the user; Min_counter ⁿ, max_counter ⁿAnd b_counter ⁿBe respectively in the n two field picture gray-scale value less than

With

Number of pixels, Δ X is the iteration weights;

In the 3rd step, segmentation stretches:

Utilize the 2nd step iteration to obtain

With

The gray-scale value that the n+1 two field picture that stretches, segmentation stretch and export behind the n+1 two field picture

$X_{\mathrm{out}}^{n+1}=\left\{\begin{array}{cc}0& \&ForAll;X_{\mathrm{in}}^{n+1}<X_{\min }^n\\ S1*(X_{\mathrm{in}}^{n+1}-X_{\min }^n)/(X_b^n-X_{\min }^n)& \&ForAll;X_{\min }^n<X_{\mathrm{in}}^{n+1}<X_b^n\\ S2*(X_{\mathrm{in}}^{n+1}-X_b^n)/(X_{\max }^n-X_b^n)& \&ForAll;X_b^n<X_{\mathrm{in}}^{n+1}<X_{\max }^n\\ S1+S2& \&ForAll;X_{\mathrm{in}}^{n+1}>X_{\max }^n\end{array}\right.$

Wherein

Be the original gray scale of n+1 frame input picture, S1 is for distributing to

Gray level, S2 is for distributing to

Gray level, S1, S2 is set by the user, the gray level that S1+S2 need be stretched to for the user.

2. method for strengthening infrared focal plane array image according to claim 1 is characterized in that: the 1st step selected for use the 3*3 square window to carry out medium filtering, and at first three column elements to a 3*3 window sort; Three row elements for the window after the row ordering sort then; Ask the intermediate value of three elements on the diagonal line at last, the gained intermediate value is exactly the intermediate value of 9 elements.

Images