Patent Publication Number: US-10776902-B2

Title: Image processing device and method for producing in real-time a digital composite image from a sequence of digital images

Description:
CROSS-REFERENCES TO RELATED APPLICATIONS 
     This application is a continuation of copending International Application No. PCT/EP2016/079324, filed Nov. 30, 2016, which is incorporated herein by reference in its entirety. 
     The present invention relates to digital image processing. More specific, the invention relates to real-time image stitching. Digital image stitching is the process of combining multiple photographic images with overlapping fields of view to produce a segmented panorama or high-resolution composite image. 
    
    
     BACKGROUND OF THE INVENTION 
     Image stitching is widely used in today&#39;s world in applications such as “Image Stabilization” feature in camcorders which use frame-rate image alignment, high resolution photo mosaics in digital maps and satellite photos, multiple image super-resolution, video stitching, object insertion and medical imaging such as microscopy or endoscopy. 
     The present invention may be useful in all applications mentioned above. However, the main applications of the invention may be seen in the field of medical endoscopy as the techniques involved may use a high degree of orientation, coordination, and fine motor skills on the part of the medical practitioner, due to the very limited field of view provided by the endoscope and the lack of relation between the orientation of the image and the physical environment. 
     SUMMARY 
     According to an embodiment, an image processing device for producing in real-time a digital composite image from a sequence of digital images recorded by a camera device, in particular an endoscopic camera device, so that the composite image has a wider field of view than the images of the sequence of images may have: a selecting unit configured for selecting a reference image and a further image from the sequence of images, wherein the reference image is specified in a global coordinate system of the composite image, wherein the further image is specified in a local coordinate system of the further image, and wherein the further image is overlapping the reference image; a key point detection unit configured for detecting one or more global key points in the reference image and for detecting one or more local key points in the further image, wherein the key point detection unit includes a smoothing filter configured for producing a filter response for the reference image and for producing a filter response for the further image, wherein the key point detection unit includes a maximum detection unit configured for detecting the one or more global key points by detecting local maxima in the filter response for the reference image and for detecting the one or more local key points by detecting local maxima in the filter response for the further image by executing following steps separately for the filter response for the reference image and for the filter response for the further image, wherein a variable threshold is used: i) creating blocks by dividing the respective filter response, ii) calculating the variable threshold, iii) discarding those blocks of the blocks from further consideration, in which the respective filter response at a reference point of the respective block is less than the respective variable threshold; a transforming unit configured for transforming the further image into the global coordinate system based on at least one of the one or more global key points and based on at least one of the one or more local key points in order to produce a transformed further image; and a joining unit configured for joining the reference image and the transformed further image in the global coordinate system in order to produce at least a part of the composite image; wherein the maximum detection unit is configured for executing following steps each time after executing step iii), wherein a constant threshold is used: iv) determining those blocks from the blocks not being discarded in step iii), in which the respective filter response at the reference point of the respective block exceeds the constant threshold, v) comparing for the determined blocks the respective filter response at the reference point with the respective filter response at points adjacent to the reference point in order to determine whether one of the local maxima is detected at the reference point; and wherein the maximum detection unit is configured for calculating the variable threshold in step ii) as a function of a dimension of the blocks, a size of the smoothing filter, the constant threshold and a steering parameter for adjusting between a high detection rate and a short computation time. 
     According to another embodiment, a camera system for producing in real-time a digital composite image may have: a camera device configured for recording a sequence of digital images, in particular an endoscopic camera device configured for recording a sequence of digital images of an interior of a hollow structure; and an inventive image processing device. 
     According to another embodiment, a method for producing in real-time a digital composite image from a sequence of digital images recorded by a camera device, in particular by an endoscopic camera device, so that the composite image has a wider field of view than the images of the sequence of images may have the steps of: selecting a reference image and a further image from the sequence of images by using a selecting unit, wherein the reference image is specified in a global coordinate system of the composite image, wherein the further image is specified in a local coordinate system of the further image, and wherein the further image is overlapping the reference image; detecting one or more global key points in the reference image and detecting one or more local key points in the further image by using a key point detection unit; wherein a filter response for the reference image and a filter response for the further image are produced by using a smoothing filter of the key point detection unit, wherein the one or more global key points are detected by detecting local maxima in the filter response for the reference image and the one or more local key points are detected by detecting local maxima in the filter response for the further image by executing steps i) to iii) separately for the filter response for the reference image and for the filter response for the further image by using a maximum detection unit of the key point detection unit, wherein a variable threshold is used, wherein the steps i) to iii) are defined as: i) creating blocks by dividing the respective filter response, ii) calculating the variable threshold, iii) discarding those blocks of the blocks from further consideration, in which the respective filter response at a reference point of the respective block is less than the respective variable threshold; transforming the further image into the global coordinate system by using a transforming unit based on at least one of the one or more global key points and based on at least one of the one or more local key points in order to produce a transformed further image; joining the reference image and the transformed further image in the global coordinate system by using a joining unit in order to produce at least a part of the composite image; and executing following steps each time after executing step iii) by using the maximum detection unit, wherein a constant threshold is used: iv) determining those blocks from the blocks not being discarded in step iii), in which the respective filter response at the reference point of the respective block exceeds the constant threshold, v) comparing for the determined blocks the respective filter response at the reference point with the respective filter response at points adjacent to the reference point in order to determine whether one of the local maxima is detected at the reference point; wherein the maximum detection unit is configured for calculating the variable threshold in step ii) as a function of a dimension of the blocks, a size of the smoothing filter, the constant threshold and a steering parameter for adjusting between a high detection rate and a short computation time. 
     Another embodiment may have a non-transitory digital storage medium having a computer program stored thereon to perform the method for producing in real-time a digital composite image from a sequence of digital images recorded by a camera device, in particular by an endoscopic camera device, so that the composite image has a wider field of view than the images of the sequence of images, the method including: selecting a reference image and a further image from the sequence of images by using a selecting unit, wherein the reference image is specified in a global coordinate system of the composite image, wherein the further image is specified in a local coordinate system of the further image, and wherein the further image is overlapping the reference image; detecting one or more global key points in the reference image and detecting one or more local key points in the further image by using a key point detection unit; wherein a filter response for the reference image and a filter response for the further image are produced by using a smoothing filter of the key point detection unit, wherein the one or more global key points are detected by detecting local maxima in the filter response for the reference image and the one or more local key points are detected by detecting local maxima in the filter response for the further image by executing steps i) to iii) separately for the filter response for the reference image and for the filter response for the further image by using a maximum detection unit of the key point detection unit, wherein a variable threshold is used, wherein the steps i) to iii) are defined as: i) creating blocks by dividing the respective filter response, ii) calculating the variable threshold, iii) discarding those blocks of the blocks from further consideration, in which the respective filter response at a reference point of the respective block is less than the respective variable threshold; transforming the further image into the global coordinate system by using a transforming unit based on at least one of the one or more global key points and based on at least one of the one or more local key points in order to produce a transformed further image; joining the reference image and the transformed further image in the global coordinate system by using a joining unit in order to produce at least a part of the composite image; and executing following steps each time after executing step iii) by using the maximum detection unit, wherein a constant threshold is used: iv) determining those blocks from the blocks not being discarded in step iii), in which the respective filter response at the reference point of the respective block exceeds the constant threshold, v) comparing for the determined blocks the respective filter response at the reference point with the respective filter response at points adjacent to the reference point in order to determine whether one of the local maxima is detected at the reference point; wherein the maximum detection unit is configured for calculating the variable threshold in step ii) as a function of a dimension of the blocks, a size of the smoothing filter, the constant threshold and a steering parameter for adjusting between a high detection rate and a short computation time, when said computer program is run by a computer. 
     The term “real-time” has to be understood in such way that each of the further images is added to the composite image in less than a second. 
     Image registration is one of the crucial steps for image mosaicking. Registration of a sequence of images refers to the process of aligning all images in a common coordinate system, i.e. finding the transformation for each image to transform its image coordinates to a global coordinate system. The image processing device is configured for pair-wise image registration. The pixel coordinates of a reference image I F  define the global coordinate system, while the image to be transformed is referred to as the further image I M . A transformation T:I M 1→I F  maps the pixel coordinates of the further image, which are given in the local coordinate system of the further image, to the global coordinate system defined by the fixed image. 
     The inventive image processing device uses a feature-based registration algorithm, which extracts salient key points from both images I F  and I M  to identify a set of corresponding points between them. A feature is a higher level description of a regional neighborhood of a key point from an image, which distinctively characterizes that regional neighborhood and can be matched to the corresponding feature from another image. Usually, the process of establishing a set of corresponding features involves three distinctive steps: key point detection, feature description, and descriptor matching. Key point detection extracts salient image points referred to as key points. Ideally, the same set of key points should be detected when applied to different image views of the same object or scene. 
     A key point consists of the two-dimensional pixel position within an image, optionally augmented by further characteristics, such as scale or orientation of the regional neighborhood. Given a set of key points, feature descriptors need to be calculated to characterize each key point&#39;s local neighborhood. A descriptor is usually represented by a vector of n real, integral, or binary numbers. Ideally, two descriptors calculated from two images showing the same physical object should be equal (or similar in practice). During the matching process, a mapping is generated to identify pairs of corresponding key points, based on their descriptors. An example of a simple matching strategy is one which maps every key point from I M  to its most similar key point from I F , with similar being defined as a small distance between key points in the n-dimensional descriptor vector space [11, 40]. 
     Key points may be extracted from the respective image as local maxima of the filter response. The filter response may be a three-dimensional function R (x, y, s), wherein x and y represent the coordinates of a pixel of the respective image and wherein s represents the scale space. 
     The final step of key point detection is the extraction of local maxima of the scale-space response volume R. To determine whether a point (x, y, s) is a local maximum, its value R (x, y, s) is compared to all values within a neighborhood region. The point is a local maximum if and only if its value is greater than all its neighbors within that region. This approach is generally known as non-maximum suppression (NMS). The neighborhood region may be defined as a block of size n x ×n y ×n s . The NMS algorithm is decisive for the overall computational performance of the key point detection method, since the comparison of function values R (x, y, s) is a very frequent operation. In prior art implementations every value is compared to its entire neighborhood, leading to a worst-case complexity of O (M·N·S·n x ·n y ·n s ) for an image of size M×N and S=O·L layers. This complexity can be significantly reduced according to the invention by early rejection of comparisons. 
     Literature explicitly dealing with NMS usually only handles the one- and two-dimensional cases. As early as 1987, Förstner and Gülch showed how to improve the naive implementation, just by altering the order of comparisons from a line-by-line scan order to a spiral scan order [3]. The idea is, that a local maximum in a (n x +1)×(n y +1) neighborhood is also a local maximum of any sub region of this neighborhood. They observed that it is advantageous to search for any pixels of greater value within the central n x ×n y  neighborhood before moving outwards, leading to the spiral scan order. This idea was further pursued by Neubeck and Van Gool who proposed a block-partitioning algorithm to accelerate NMS for the two-dimensional case [6]. This reduces the average number of comparisons needed for (n x ×n y )-NMS below 2.39. Pham accomplished to further drop this number below two comparisons per pixel, independent of the neighborhood size [7]. All of the presented algorithms can, in principal, be adapted to the useful three-dimensional case. 
     It is worth noting that the benefit of these algorithms over the straightforward implementation increases with the neighborhood size. Pham showed that the performance of Förstner&#39;s spiral ordering method is comparable to the newer methods up to a neighborhood size of 11×11 pixels. Most feature detectors use a 3×3×3 neighborhood. It can be concluded that the impact of choosing one of the presented NMS schemes has little impact on the detector&#39;s computation time. Nevertheless, there is much room for improvement by choosing an appropriate sampling scheme within the scale-space R. Since the density of possible key points decreases at higher scales, most authors follow a pyramidal approach. They start by sampling every pixel at the lowest pyramid level and reduce the sampling rate by a factor of two for every octave. Thus, the number of points (x, y, s) to check for local maxima is reduced exponentially for higher pyramid levels. The obvious disadvantage of this strategy is the increasing risk of missing local maxima or locating them less precisely. Therefore, the maxima are usually quadratically interpolated between the sampling points as a refinement step. Agrawal et al. argue that they achieve a higher accuracy by sampling the entire volume at the full resolution [1]. This becomes feasible due to their implementation of a key point detector as difference-of-boxes. 
     The image processing device according to the invention is configured for executing a hierarchical local maxima search. The key concept of hierarchical local maxima search is the reduction of sampling points by skipping points which can be assumed to be smaller than a minimum value. The sampling mechanism is based on an octree representation of sampling points in the filter response. Every tree node represents a block within the filter responds and contains its dimensions (m, m, n), a reference point (x r , y r , s r ), and a variable threshold (t). First, the entire filter response may be divided into blocks of an initial size m 0 ×m 0 ×n 0 . Each block may then be divided recursively into eight (sub-)blocks with dimensions (m i , m i , n i ), so that every tree node has eight children. During local maxima search the tree is traversed in a depth-first manner. For every traversed block, the filter response R (x r , y r , s r ) is evaluated. The result is compared to the variable threshold t. If R (x r , y r , s r )&lt;t, it is assumed that all points within the respective block evaluate to a value smaller than a minimum value and can be neglected. Thus, the respective clock may be discarded from further consideration If, on the other hand, R (x r , y r , s r )≥t, points in the respective block may evaluate to values greater than the minimum value. In this case all eight children of the respective block are processed. This strategy quickly traverses blocks of the filter response with low filter responses and effectively reduces the number of function evaluations. 
     The invention provides an image processing device being configured for executing a new NMS method, which significantly reduces the number of samples within the scale-space without sacrificing for key point localization accuracy, so that the computational effort is lowered significantly. 
     According to an embodiment of the invention will the maximum detection unit is configured for executing following steps each time after executing step iii), wherein a constant threshold is used: 
     iv) determining those blocks from the blocks not being discarded in step iii), in which the respective filter response at the reference point of the respective block exceeds the constant threshold, 
     v) comparing for the determined blocks the respective filter response at the reference point with the respective filter response at points adjacent to the reference point in order to determine whether one of the local maxima is detected at the reference point. 
     Unlike all other NMS approaches, the inventive image processing device may take the value of the filter response R (x r , y r , s r ) into account to decide whether neighboring positions need to be processed or not. It can be observed that the filter response is a smooth function, especially for higher scale levels. 
     If the filter response at a reference point is lower than the constant threshold, the probability that the values of the filter response will exceed the constant threshold in a certain neighborhood is low, as well. Consequently, these positions do not need to be evaluated. The size of this neighborhood depends on the actual value of the filter response at that point and the value of the constant threshold. A sampling scheme based on values of the filter response does not require a fixed sampling pattern, but adapts itself to the image content. 
     If R (x r , y r , s r ) is found to even exceed the constant threshold it is a possible candidate for a local maximum and may be compared to its n x ×n y ×n s  neighbors. All local maxima, that exceed the constant threshold, are considered as key points, since a high filter response is associated with a high probability of being a repeatable key point location. The constant threshold is used to adjust the minimum response expected for a key point to be stable and thus influences the number of key points which are detected. 
     According to an embodiment of the invention the maximum detection unit is configured for executing following steps each time after executing step iii) until a truncation condition occurs: 
     vi) creating blocks by dividing the blocks not being discarded in step iii), 
     vii) executing of steps ii) to vi) for the blocks created in step vi). 
     Steps vi) and vii) may be repeated until a truncation condition, in which a block size of one pixel is reached, occurs. That way, the volume is densely sampled around points larger than the variable threshold. Alternatively, the process of block division can be repeated until a truncation condition, in which a block size of more than on pixel (depending on the current scale) is reached, occurs. This incorporates the idea of reducing the sampling density at higher scale levels. The block size of the truncation condition may be defined as 2 [s/L] , wherein s is the scale level and L is the number of levels per octave, i.e. for every octave the block size for the truncation condition is doubled, starting at 1×1×1 for the first octave. 
     According to an embodiment of the invention the maximum detection unit is configured for dividing the filter response in step i) as a function of a scale level and a number of levels per octave in such way that the blocks all have a same size. 
     The block size resulting from step i) may be chosen depending on the scale level s. Blocks are larger on higher scale levels, since local maxima are expected to lie farther apart. For the step of dividing the filter response into blocks, the block size may be defined as m 0 =8·w(s), n 0 =2·L, wherein w(s) is the filter kernel size at the scale level s and L is the number of levels per octave, covering eight times the filter kernel size and two octaves. 
     According to an embodiment of the invention the maximum detection unit is configured for creating the blocks in step vi) in such way that the size of the blocks not being discarded in step iii) is divided in halves for all dimensions. 
     For all steps of dividing the blocks into smaller blocks, the size may be divided by two for all dimensions: m i =(m i-1 )/2, n i =(n i-1 )/2). 
     According to an embodiment of the invention the maximum detection unit is configured for calculating the variable threshold in step ii) as a function of a dimension of the blocks, a size of the filter and the constant threshold. 
     A crucial part of the hierarchical search strategy is the determination of the variable threshold values t i . These variable thresholds t i  have to be chosen such that an acceptably small number of local maxima are missed. The variable thresholds t i , may depend on the dimension of the block (m i , m i , n i ), the filter kernel size w(s) at the current scale level s, the constant threshold T, and a steering parameter α according to: 
     
       
         
           
             
               
                 
                   
                     
                       t 
                       i 
                       ′ 
                     
                     = 
                     
                       T 
                       ⁡ 
                       
                         ( 
                         
                           1 
                           - 
                           
                             α 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               
                                 m 
                                 i 
                               
                               
                                 w 
                                 ⁡ 
                                 
                                   ( 
                                   s 
                                   ) 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                   , 
                   
                     
                       t 
                       i 
                     
                     = 
                     
                       { 
                       
                         
                           
                             
                               
                                 t 
                                 i 
                                 ′ 
                               
                             
                             
                               
                                 
                                   if 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     t 
                                     i 
                                     ′ 
                                   
                                 
                                 ≥ 
                                 0 
                               
                             
                           
                           
                             
                               0 
                             
                             
                               else 
                             
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
     The parameter α, which is a non-negative real number, may be used to adjust the “sensitivity”. For α=0, a block is skipped as soon as the filter response is below ti=T. This usually leads to an unacceptably high number of missed local maxima. For higher values of α more blocks are processed, so that less maxima are missed, but processing time increases. Thus, α allows to adjust between high detection rate and short computation time. An appropriate value for a may be determined experimentally. 
     The following table provides a comparison of local maxima search strategies. The sampling rate is the ratio of samples taken from scale-space. The detection rate is the number of detected key points. Both rates are measured in reference to the full sampling scheme. The processing time per image includes the constant overhead of initialization and integral image calculation, which makes up 7 ms for each algorithm. All measurements are average values over 100 cystoscopic images. 
     
       
         
           
               
               
               
               
               
             
               
                   
               
               
                 Sampling 
                 α 
                 sampling rate [%] 
                 Detection rate [%] 
                 Time [ms] 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
               
            
               
                 Full 
                   
                 100.0 
                 100.0 
                 53.2 
               
               
                 Pyramidal 
                   
                 18.4 
                 90.3 
                 17.7 
               
               
                 Hierarchical 
                 0.8 
                 9.94 
                 85.6 
                 21.4 
               
               
                   
                 1.0 
                 13.0 
                 97.7 
                 23.3 
               
               
                   
                 1.5 
                 18.3 
                 99.4 
                 25.9 
               
               
                 Truncated 
                 0.8 
                 4.3 
                 77.8 
                 11.2 
               
               
                 hierarchical 
                 1.0 
                 6.6 
                 88.6 
                 12.3 
               
               
                   
                 1.5 
                 10.3 
                 90.0 
                 13.9 
               
               
                   
               
            
           
         
       
     
     According to embodiment of the invention the maximum detection unit is configured for using a central point of the respective block as the reference point of the respective block in step iii). The central point of a block is a point of the block which is closest to the center of the respective block. 
     According to an embodiment of the invention the key point detection unit comprises an integral image calculator configured for calculating a reference integral image from the reference image and a further integral image from the further image, wherein the filter response for the reference image is produced by feeding the reference integral image to the filter and wherein the filter response for the further image is produced by feeding the further integral image to the filter. 
     Integral images are also known as summed area tables. An image can be interpreted as the two-dimensional function I (x, y). Then, the integral image I Σ  is an intermediate representation of the discrete cumulative distribution function of I: 
     
       
         
           
             
               
                 
                   
                     
                       I 
                       Σ 
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         ≤ 
                         
                           x 
                           ⋀ 
                           j 
                         
                         ≤ 
                         y 
                       
                     
                     ⁢ 
                     
                       
                         I 
                         ⁡ 
                         
                           ( 
                           
                             i 
                             , 
                             j 
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
     So, every value in I Σ  represents the sum of all pixel values of the upper left region of the original image. The sum of any rectangular image area ABCD with A=(x 0 , y 0 ), B=(x 0 , y 1 ), C=(x 1 , y 0 ), D=(x 1 , y 1 ) can be calculated with only four array references in the integral image as 
     
       
         
           
             
               
                 
                   
                     
                       ∑ 
                       
                         
                           
                             x 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             0 
                           
                           &lt; 
                           x 
                           ≤ 
                           
                             x 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             1 
                           
                         
                         
                           
                             y 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             0 
                           
                           &lt; 
                           y 
                           ≤ 
                           
                             y 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             1 
                           
                         
                       
                       
                           
                       
                     
                     ⁢ 
                     
                       I 
                       ⁡ 
                       
                         ( 
                         
                           x 
                           , 
                           y 
                         
                         ) 
                       
                     
                   
                   = 
                   
                     
                       
                         I 
                         Σ 
                       
                       ⁡ 
                       
                         ( 
                         D 
                         ) 
                       
                     
                     - 
                     
                       
                         I 
                         Σ 
                       
                       ⁡ 
                       
                         ( 
                         B 
                         ) 
                       
                     
                     - 
                     
                       
                         I 
                         Σ 
                       
                       ⁡ 
                       
                         ( 
                         C 
                         ) 
                       
                     
                     + 
                     
                       
                         
                           I 
                           Σ 
                         
                         ⁡ 
                         
                           ( 
                           A 
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
     Computation of the integral image can be achieved efficiently in a single pass of the original image as 
     
       
         
           
             
               
                 
                   
                     
                       I 
                       Σ 
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       I 
                       ⁡ 
                       
                         ( 
                         
                           x 
                           , 
                           y 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         I 
                         Σ 
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             x 
                             - 
                             1 
                           
                           , 
                           y 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         I 
                         Σ 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           , 
                           
                             y 
                             - 
                             1 
                           
                         
                         ) 
                       
                     
                     - 
                     
                       
                         
                           I 
                           Σ 
                         
                         ⁡ 
                         
                           ( 
                           
                             
                               x 
                               - 
                               1 
                             
                             , 
                             
                               y 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
     An average filter for image smoothing, for example is implemented by calculating the pixel sum within the filter kernel region with equation (3) divided by the number of pixels within this region. 
     In combination with integral image based filtering, a sampling scheme using the variable threshold and optionally the constant threshold does not only save comparisons between filter response values during NMS, but actually reduces the number of points, at which the filter response has to be calculated. Lowe already suggested reducing the computational load by subsampling the image for every octave [5]. Lindeberg presented a fast automatic scale selection algorithm, which uses a binomial filtering instead of Gaussian smoothing. Both of these suggestions aim at reducing the number of sampling points for which a filter response is calculated. Since integral image based filtering is performed independently for every pixel and every scale level, it optimally qualifies for implementing a selective sampling scheme using the variable threshold and optionally the constant threshold. 
     According to an embodiment of the invention the filter is configured in such way that each of the filter response for the reference image and the filter response for the further image is equivalent to an absolute difference of two smoothing filter responses of the respective image at different levels of a scale space. 
     The filter responses at a pixel position (x, y) of image I may be calculated as the absolute differences of two parabolic filter responses at two levels of the scale space. The levels can be defined in terms of the scale level s. s defines the window widths w(s) and w′(s) of the respective smoothing filter kernels p w(s)  and p w′(s) . The filter response volume R may be calculated as
 
 ( x,y,s )=|( I*p   w(s) )( x,y )−( I*p   w′(s) )( x,y )|,  (5)
 
     The scale-space depends on two parameters, the number of octaves O and the number of levels per octave L. The step from one octave to the next is achieved by doubling the filter kernel size. For scale-space key point detectors, common values range from O=4 to 7 for the number of octaves and L=2 to 4 for the number of levels per octave. The functions w(s) and w(s) to determine the filter kernel sizes for scale parameter sε[L, O·L] may be defined as 
     
       
         
           
             
               
                 
                   
                     
                       w 
                       ⁡ 
                       
                         ( 
                         s 
                         ) 
                       
                     
                     = 
                     
                       
                         2 
                         ⁢ 
                         
                           ⌈ 
                           
                             2 
                             
                               
                                 ( 
                                 
                                   s 
                                   + 
                                   2 
                                 
                                 ) 
                               
                               / 
                               L 
                             
                           
                           ⌉ 
                         
                       
                       + 
                       1 
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         w 
                         ′ 
                       
                       ⁡ 
                       
                         ( 
                         s 
                         ) 
                       
                     
                     = 
                     
                       
                         2 
                         ⁢ 
                         
                           ⌈ 
                           
                             2 
                             
                               s 
                               / 
                               L 
                             
                           
                           ⌉ 
                         
                       
                       + 
                       1. 
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
     Choosing O=6, L=2 and rounding the filter sizes to integrals leads to a set of filter kernel sizes {5, 7, 9, 13, 17, 25, 33, 47, 65, 93, 129, 183, 257}. 
     According to an embodiment of the invention each of the two smoothing filter responses is a parabolic filter response. 
     According to prior art, integral images have only been applied to box filters (e.g. average filters and Haar wavelets). Witkin introduced the concept of scale-space to represent the inherent structure of a signal on different scales in 1983 [38, 39]. The scale-space of an image may be generated by smoothing the image with a set of filter kernels of increasing size. The kernel size defines the scale parameter s. With increasing scale, more and more image structure is suppressed. Lindeberg identified the Gaussian function to be the only valid smoothing function to generate a linear (Gaussian) scale-space representation. Linear scale-space guarantees that structure is only suppressed and not newly created with increasing scale. 
     Nonetheless, Gaussian filtering isn&#39;t used in practice to create the scale space because it may use a severe amount of computing power and time. Instead, many algorithms are based on approximations to the Gaussian filter kernel to reduce the computational load and increase processing speed. The box filter is one popular approximation, since it can be efficiently calculated using integral images. However, the box filter is not in accordance with the scale-space axioms and results in artifacts in the scale-space representation of the image. Polynomial functions approximate a Gaussian kernel better than box functions, making them more suitable for building a scale-space. 
     Filtering the image I with a filter kernel k of size (w+1)×(w+1) (w even-numbered) by convolution is defined as 
     
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         I 
                         * 
                         k 
                       
                       ) 
                     
                     ⁢ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         u 
                         = 
                         
                           
                             - 
                             w 
                           
                           / 
                           2 
                         
                       
                       
                         w 
                         / 
                         2 
                       
                     
                     ⁢ 
                     
                       
                         ∑ 
                         
                           v 
                           = 
                           
                             
                               - 
                               w 
                             
                             / 
                             2 
                           
                         
                         
                           w 
                           / 
                           2 
                         
                       
                       ⁢ 
                       
                         
                           k 
                           ⁡ 
                           
                             ( 
                             
                               u 
                               , 
                               v 
                             
                             ) 
                           
                         
                         ⁢ 
                         
                           
                             I 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   - 
                                   u 
                                 
                                 , 
                                 
                                   y 
                                   - 
                                   v 
                                 
                               
                               ) 
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
     Substituting i=x−u and j=y−v yields 
     
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         I 
                         * 
                         k 
                       
                       ) 
                     
                     ⁢ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         
                           x 
                           - 
                           
                             w 
                             / 
                             2 
                           
                         
                       
                       
                         x 
                         + 
                         
                           w 
                           / 
                           2 
                         
                       
                     
                     ⁢ 
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           
                             y 
                             - 
                             
                               w 
                               / 
                               2 
                             
                           
                         
                         
                           y 
                           + 
                           
                             w 
                             / 
                             2 
                           
                         
                       
                       ⁢ 
                       
                         
                           k 
                           ⁡ 
                           
                             ( 
                             
                               
                                 x 
                                 - 
                                 i 
                               
                               , 
                               
                                 y 
                                 - 
                                 j 
                               
                             
                             ) 
                           
                         
                         ⁢ 
                         
                           
                             I 
                             ⁡ 
                             
                               ( 
                               
                                 i 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
     For a box filter with kernel 
                   b   =       (     1       (     w   +   1     )     2       )         (     w   +   1     )     ×     (     w   +   1     )                 (   9   )               
this can be reduced to
 
     
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         I 
                         * 
                         b 
                       
                       ) 
                     
                     ⁢ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       1 
                       
                         
                           ( 
                           
                             w 
                             + 
                             1 
                           
                           ) 
                         
                         2 
                       
                     
                     ⁢ 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           
                             x 
                             - 
                             
                               w 
                               / 
                               2 
                             
                           
                         
                         
                           x 
                           + 
                           
                             w 
                             / 
                             2 
                           
                         
                       
                       ⁢ 
                       
                         
                           ∑ 
                           
                             j 
                             = 
                             
                               y 
                               - 
                               
                                 w 
                                 / 
                                 2 
                               
                             
                           
                           
                             y 
                             + 
                             
                               w 
                               / 
                               2 
                             
                           
                         
                         ⁢ 
                         
                           
                             I 
                             ⁡ 
                             
                               ( 
                               
                                 i 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
     The double sum on the right hand side can be evaluated using the integral image of I. This is possible, because b is independent of i and j and can thus be removed from the sum. Let p be a polynomial kernel function of degree n: 
     
       
         
           
             
               
                 
                   
                     p 
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         
                           r 
                           = 
                           0 
                         
                         
                           s 
                           = 
                           0 
                         
                       
                       
                         
                           r 
                           + 
                           s 
                         
                         ≤ 
                         n 
                       
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         a 
                         rs 
                       
                       ⁢ 
                       
                         x 
                         r 
                       
                       ⁢ 
                       
                         
                           y 
                           s 
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
     Following (8) and introducing the short notation 
     for the double sum
 
Σ i=x−w/2   x+w/2 Σ j=y−w/2   y+w/2 ,
 
the respective filter operation is
 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             ( 
                             
                               I 
                               * 
                               p 
                             
                             ) 
                           
                           ⁢ 
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         = 
                           
                         ⁢ 
                         
                           
                             ∑ 
                             
                               i 
                               , 
                               j 
                             
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               p 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     - 
                                     i 
                                   
                                   , 
                                   
                                     y 
                                     - 
                                     j 
                                   
                                 
                                 ) 
                               
                             
                             ⁢ 
                             
                               I 
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                         ⁢ 
                         
                           
                             ∑ 
                             
                               i 
                               , 
                               j 
                             
                           
                           ⁢ 
                           
                             
                               ( 
                               
                                 
                                   ∑ 
                                   
                                     
                                       r 
                                       = 
                                       0 
                                     
                                     
                                       s 
                                       = 
                                       0 
                                     
                                   
                                   
                                     
                                       r 
                                       + 
                                       s 
                                     
                                     ≤ 
                                     n 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       
                                         a 
                                         rs 
                                       
                                       ⁡ 
                                       
                                         ( 
                                         
                                           x 
                                           - 
                                           i 
                                         
                                         ) 
                                       
                                     
                                     r 
                                   
                                   ⁢ 
                                   
                                     
                                       ( 
                                       
                                         y 
                                         - 
                                         j 
                                       
                                       ) 
                                     
                                     s 
                                   
                                 
                               
                               ) 
                             
                             ⁢ 
                             
                               I 
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                         ⁢ 
                         
                           
                             ∑ 
                             
                               i 
                               , 
                               j 
                             
                           
                           ⁢ 
                           
                             
                               ∑ 
                               
                                 
                                   r 
                                   = 
                                   0 
                                 
                                 
                                   s 
                                   = 
                                   0 
                                 
                               
                               
                                 
                                   r 
                                   + 
                                   s 
                                 
                                 ≤ 
                                 n 
                               
                             
                             ⁢ 
                             
                               
                                 
                                   
                                     a 
                                     rs 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       x 
                                       - 
                                       i 
                                     
                                     ) 
                                   
                                 
                                 r 
                               
                               ⁢ 
                               
                                 
                                   ( 
                                   
                                     y 
                                     - 
                                     j 
                                   
                                   ) 
                                 
                                 s 
                               
                               ⁢ 
                               
                                 
                                   I 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                                 . 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
     Applying the binomial theorem 
                         (     x   -   i     )     r     ⁢       (     y   -   j     )     s       =       ∑     f   =   0     r     ⁢           ⁢       (         r           f         )     ⁢         x     r   -   f       ⁡     (     -   i     )       f     ⁢       ∑     g   =   0     s     ⁢       (         s           g         )     ⁢         y     s   -   g       ⁡     (     -   j     )       g                     (   13   )               
and the distributive law yields
 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             ( 
                             
                               I 
                               * 
                               p 
                             
                             ) 
                           
                           ⁢ 
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         = 
                           
                         ⁢ 
                         
                           
                             ∑ 
                             
                               i 
                               , 
                               j 
                             
                           
                           ⁢ 
                           
                             
                               ∑ 
                               
                                 
                                   r 
                                   = 
                                   0 
                                 
                                 
                                   s 
                                   = 
                                   0 
                                 
                               
                               
                                 
                                   r 
                                   + 
                                   s 
                                 
                                 ≤ 
                                 n 
                               
                             
                             ⁢ 
                             
                               
                                 ∑ 
                                 
                                   
                                     f 
                                     = 
                                     0 
                                   
                                   
                                     g 
                                     = 
                                     0 
                                   
                                 
                                 
                                   
                                     g 
                                     ≤ 
                                     s 
                                   
                                   
                                     f 
                                     ≤ 
                                     r 
                                   
                                 
                               
                               ⁢ 
                               
                                 
                                   
                                     a 
                                     rs 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       
                                         
                                           r 
                                         
                                       
                                       
                                         
                                           f 
                                         
                                       
                                     
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       x 
                                       
                                         r 
                                         - 
                                         f 
                                       
                                     
                                     ⁡ 
                                     
                                       ( 
                                       
                                         - 
                                         i 
                                       
                                       ) 
                                     
                                   
                                   f 
                                 
                                 ⁢ 
                                   
                                 ⁢ 
                                 
                                   ( 
                                   
                                     
                                       
                                         s 
                                       
                                     
                                     
                                       
                                         g 
                                       
                                     
                                   
                                   ) 
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       y 
                                       
                                         s 
                                         - 
                                         g 
                                       
                                     
                                     ⁡ 
                                     
                                       ( 
                                       
                                         - 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   g 
                                 
                                 ⁢ 
                                 
                                   I 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                         ⁢ 
                         
                           
                             ∑ 
                             
                               
                                 r 
                                 = 
                                 0 
                               
                               
                                 s 
                                 = 
                                 0 
                               
                             
                             
                               
                                 r 
                                 + 
                                 s 
                               
                               ≤ 
                               n 
                             
                           
                           ⁢ 
                           
                             
                               ∑ 
                               
                                 
                                   f 
                                   = 
                                   0 
                                 
                                 
                                   g 
                                   = 
                                   0 
                                 
                               
                               
                                 
                                   g 
                                   ≤ 
                                   s 
                                 
                                 
                                   f 
                                   ≤ 
                                   r 
                                 
                               
                             
                             ⁢ 
                             
                               
                                 
                                   a 
                                   rs 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       
                                         r 
                                       
                                     
                                     
                                       
                                         f 
                                       
                                     
                                   
                                   ) 
                                 
                               
                               ⁢ 
                               
                                 
                                   x 
                                   
                                     r 
                                     - 
                                     f 
                                   
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       
                                         s 
                                       
                                     
                                     
                                       
                                         g 
                                       
                                     
                                   
                                   ) 
                                 
                               
                               ⁢ 
                               
                                 y 
                                 
                                   s 
                                   - 
                                   g 
                                 
                               
                               ⁢ 
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       ( 
                                       
                                         - 
                                         i 
                                       
                                       ) 
                                     
                                     f 
                                   
                                   ⁢ 
                                   
                                     
                                       ( 
                                       
                                         - 
                                         j 
                                       
                                       ) 
                                     
                                     g 
                                   
                                   ⁢ 
                                   
                                     
                                       I 
                                       ⁡ 
                                       
                                         ( 
                                         
                                           i 
                                           , 
                                           j 
                                         
                                         ) 
                                       
                                     
                                     . 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
     Shifting the bounds of summation accordingly, the order of summation is interchanged: 
                         (     I   *   p     )     ⁢     (     x   ,   y     )       =       ∑       f   =   0       g   =   0           f   +   g     ≤   n       ⁢       ∑       r   =   f       s   =   g           r   +   s     ≤   n       ⁢         a   rs     ⁡     (         r           f         )       ⁢       x     r   -   f       ⁡     (         s           g         )       ⁢     y     s   -   g       ⁢       ∑     i   ,   j       ⁢         (     -   i     )     f     ⁢       (     -   j     )     g     ⁢     I   ⁡     (     i   ,   j     )                   ,           (   15   )               
leading to a compact formulation of the polynomial filter equation:
 
                         (     I   *   p     )     ⁢     (     x   ,   y     )       =       ∑       f   =   0     ,     g   =   0           f   +   g     ≤   n       ⁢         ξ   fg     ⁡     (     x   ,   y     )       ⁢       ∑     i   =     x   -     w   /   2           x   +     w   /   2         ⁢           ⁢       ∑     j   =     y   -     w   /   2           y   +     w   /   2         ⁢       i   f     ⁢     j   g     ⁢     I   ⁡     (     i   ,   j     )                   ,           (   16   )               
where the coefficients are calculated as
 
     
       
         
           
             
               
                 
                   
                     
                       ξ 
                       fg 
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         
                           r 
                           = 
                           f 
                         
                         
                           s 
                           = 
                           g 
                         
                       
                       
                         
                           r 
                           + 
                           s 
                         
                         ≤ 
                         n 
                       
                     
                     ⁢ 
                     
                       
                         
                           ( 
                           
                             - 
                             1 
                           
                           ) 
                         
                         
                           f 
                           + 
                           g 
                         
                       
                       ⁢ 
                       
                         
                           a 
                           rs 
                         
                         ⁡ 
                         
                           ( 
                           
                             
                               
                                 r 
                               
                             
                             
                               
                                 f 
                               
                             
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           x 
                           
                             r 
                             - 
                             f 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             
                               
                                 s 
                               
                             
                             
                               
                                 g 
                               
                             
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           y 
                           
                             s 
                             - 
                             g 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
     Since the inner summands in (16) are independent of x and y, the inner double sum can be pre-calculated to accelerate the computation of the filter response. Let I fg   Σ  be defined as 
     
       
         
           
             
               
                 
                   
                     
                       I 
                       fg 
                       Σ 
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         ≤ 
                         
                           x 
                           ⁢ 
                           
                               
                           
                           ⋀ 
                           j 
                         
                         ≤ 
                         y 
                       
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         i 
                         f 
                       
                       ⁢ 
                       
                         j 
                         g 
                       
                       ⁢ 
                       
                         
                           I 
                           ⁡ 
                           
                             ( 
                             
                               i 
                               , 
                               j 
                             
                             ) 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
     Then, I 00   Σ  is equivalent to the conventional integral image I Σ  for implementing a box filter. All integral images I fg   Σ  with f≥0, f≥0, f+g≤n are needed to implement a polynomial filter of order n, resulting in 
                     (           n   +   2             2         )     =         (     n   +   1     )     ⁢     (     n   +   2     )       2             (   19   )               
integral images. Evaluating the sum over a rectangular region can be achieved with four array references (and three summations). Let us define a compact notation for one such evaluation as
 
 A   fg ( x,y )= I   fg   Σ ( D )− I   fg   Σ ( B )− I   fg   Σ ( C )+ I   fg   Σ ( A )  (20)
 
with ABCD the image region covered by the filter mask around (x; y), so
 
 A =( x−w/ 2, y−w/ 2),
 
 B =( x−w/ 2, y+w/ 2),
 
 C =( x+w/ 2, y−w/ 2),
 
 D =( x+w/ 2, y+w/ 2).  (21)
 
     Then (16) can be written as 
     
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         I 
                         * 
                         p 
                       
                       ) 
                     
                     ⁢ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         
                           f 
                           = 
                           0 
                         
                         , 
                         
                           g 
                           = 
                           0 
                         
                       
                       
                         
                           f 
                           + 
                           g 
                         
                         ≤ 
                         n 
                       
                     
                     ⁢ 
                     
                       
                         
                           ξ 
                           fg 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             , 
                             y 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           
                             𝒜 
                             fg 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
     A total of 
                     4   ·     (           n   +   2             2         )       =     2   ⁢     (     n   +   1     )     ⁢     (     n   +   2     )               (   22   )               
access operations may be used to evaluate the filter response in one point (independent of the window size). Consider for example the implementation of a filter kernel based on a quadratic function (n=2). Then, six integral images have to be pre-calculated and 24 array references may be used to evaluate the filter response in one point. This will be further considered below, where this theory is used to design a paraboloid filter to approximate a two-dimensional Gaussian smoothing filter. Computation of the images I fg   Σ  is straight forward. E.g., image I 12   Σ  iteratively computed as
 
     
       
         
           
             
               
                 
                   
                     
                       I 
                       12 
                       Σ 
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         xy 
                         2 
                       
                       ⁢ 
                       
                         I 
                         ⁡ 
                         
                           ( 
                           
                             x 
                             , 
                             y 
                           
                           ) 
                         
                       
                     
                     + 
                     
                       
                         I 
                         12 
                         Σ 
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             x 
                             - 
                             1 
                           
                           , 
                           y 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         I 
                         12 
                         Σ 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           , 
                           
                             y 
                             - 
                             1 
                           
                         
                         ) 
                       
                     
                     - 
                     
                       
                         
                           I 
                           12 
                           Σ 
                         
                         ⁡ 
                         
                           ( 
                           
                             
                               x 
                               - 
                               1 
                             
                             , 
                             
                               y 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
     All integral images are calculated in one single pass over the source image. 
     The paraboloid filter kernel p(x, y) may be modeled by the quadratic function
 
 p ( x,y )=− a ( x   2   +y   2   +b.   (24)
 
     The filter response may be calculated as 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             ( 
                             
                               I 
                               * 
                               p 
                             
                             ) 
                           
                           ⁢ 
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         = 
                           
                         ⁢ 
                         
                           
                             ∑ 
                             
                               i 
                               , 
                               j 
                             
                           
                           ⁢ 
                           
                             
                               ( 
                               
                                 
                                   - 
                                   
                                     a 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         
                                           
                                             ( 
                                             
                                               x 
                                               - 
                                               i 
                                             
                                             ) 
                                           
                                           2 
                                         
                                         + 
                                         
                                           
                                             ( 
                                             
                                               y 
                                               - 
                                               j 
                                             
                                             ) 
                                           
                                           2 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                                 + 
                                 b 
                               
                               ) 
                             
                             ⁢ 
                             
                               I 
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                         ⁢ 
                         
                           
                             
                               - 
                               a 
                             
                             ⁢ 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   , 
                                   j 
                                 
                               
                               ⁢ 
                               
                                 
                                   ( 
                                   
                                     
                                       x 
                                       2 
                                     
                                     - 
                                     
                                       2 
                                       ⁢ 
                                       xi 
                                     
                                     + 
                                     
                                       i 
                                       2 
                                     
                                   
                                   ) 
                                 
                                 ⁢ 
                                 
                                   I 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             a 
                             ⁢ 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   , 
                                   j 
                                 
                               
                               ⁢ 
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       2 
                                     
                                     - 
                                     
                                       2 
                                       ⁢ 
                                       yi 
                                     
                                     + 
                                     
                                       j 
                                       2 
                                     
                                   
                                   ) 
                                 
                                 ⁢ 
                                 
                                   I 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                           + 
                           
                             b 
                             ⁢ 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   , 
                                   j 
                                 
                               
                               ⁢ 
                               
                                 I 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           = 
                             
                           ⁢ 
                           
                             
                               
                                 - 
                                 a 
                               
                               ⁢ 
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     ( 
                                     
                                       
                                         i 
                                         2 
                                       
                                       + 
                                       
                                         j 
                                         2 
                                       
                                     
                                     ) 
                                   
                                   ⁢ 
                                   
                                     I 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                             + 
                             
                               2 
                               ⁢ 
                               a 
                             
                           
                         
                         , 
                         
                           
                             x 
                             ⁢ 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   , 
                                   j 
                                 
                               
                               ⁢ 
                               
                                 iI 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                   ) 
                                 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             2 
                             ⁢ 
                             ay 
                             ⁢ 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   , 
                                   j 
                                 
                               
                               ⁢ 
                               
                                 jI 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                   ) 
                                 
                               
                             
                           
                           + 
                           
                             
                               ( 
                               
                                 
                                   - 
                                   
                                     a 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         
                                           x 
                                           2 
                                         
                                         + 
                                         
                                           y 
                                           2 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                                 + 
                                 b 
                               
                               ) 
                             
                             ⁢ 
                             
                               
                                 ∑ 
                                 
                                   i 
                                   , 
                                   j 
                                 
                               
                               ⁢ 
                               
                                 I 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   25 
                   ) 
                 
               
             
           
         
       
     
     Applying the formulation in (16) and the definition in (20) shows how to use integral images: 
     
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         I 
                         * 
                         p 
                       
                       ) 
                     
                     ⁢ 
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       - 
                       
                         a 
                         ⁡ 
                         
                           ( 
                           
                             
                               
                                 𝒜 
                                 20 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   x 
                                   , 
                                   y 
                                 
                                 ) 
                               
                             
                             + 
                             
                               
                                 𝒜 
                                 02 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   x 
                                   , 
                                   y 
                                 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                     
                     + 
                     
                       2 
                       ⁢ 
                       
                         ax 
                         ⁢ 
                         
                             
                         
                         · 
                         
                           
                             𝒜 
                             10 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       2 
                       ⁢ 
                       
                         ay 
                         ⁢ 
                         
                             
                         
                         · 
                         
                           
                             𝒜 
                             01 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         ( 
                         
                           
                             - 
                             
                               a 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     2 
                                   
                                   + 
                                   
                                     y 
                                     2 
                                   
                                 
                                 ) 
                               
                             
                           
                           + 
                           b 
                         
                         ) 
                       
                       · 
                       
                         
                           
                             𝒜 
                             00 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   26 
                   ) 
                 
               
             
           
         
       
     
     The use of a parabolic filter response allows the use of the variable threshold and the constant threshold during NME as outlined above, whilst the use of the thresholds is not possible for Laplacian of Gaussian (LOG) filters or difference of Gaussians (DOG) filters, which use convolution to produce a filter response at full image resolution for every scale level. 
     Since the parabolic filter kernels are normalized by itself, there is no need to do any further normalization step of the response R to the parabolic filter. 
     According to an embodiment of the invention the transforming unit comprises 
     a feature descriptor calculating unit configured for calculating for each global key point a global feature descriptor characterizing a regional neighborhood of the respective global key point and for calculating for each local key point a local feature descriptor characterizing a regional neighborhood of the local key point;
 
a descriptor matching unit configured for comparing the one or more local feature descriptors with the one or more global feature descriptors in order to identify matching features in the reference image and in the further image; and
 
a transforming execution unit configured for transforming the further image into the global coordinate system based on the matching features in order to produce the transformed further image;
 
wherein the feature descriptor calculating unit is configured in such way that the one or more global feature descriptors characterizing the regional neighborhood of the respective global key point and the one or more local feature descriptors characterizing the regional neighborhood of the respective local key point each are represented by a bit vector;
 
wherein each bit of the bit vector encodes a characteristic of a pixel position in the respective neighborhood;
 
wherein the respective neighborhood is divided into sectors of a same size;
 
wherein each sector comprises a group of the pixel positions;
 
wherein the groups are arranged rotationally symmetric with regard to rotations around the respective key point with a rotation angle, which is equal to a central angle of the sectors or a multiple of the central angle of the sectors; and
 
wherein all bits of the bit vector are arranged in such order that a bit shift operation of the bit vector, in which a number of the shifted bits is equal to a number of bits per group, is equivalent to a rotation of the respective neighborhood by the central angle.
 
     The following explanations refer to global feature descriptors as well as to local feature descriptors. Feature descriptors vary with a change of appearance of an object in the image. Robust feature matching under realistic circumstances may use invariance of the descriptors to certain changes. Various descriptors offer invariance to different aspects of appearance, including changing image brightness or contrast, image rotation or scaling, or even an affine transformation of the image region (due to a change of perspective). If a certain variance is expected for a given problem, a feature descriptor behaving invariantly to such changes of appearance facilitates feature matching. On the other hand, this comes at the price of lower descriptor distinctiveness, since the difference of appearance of two different objects may not be distinguishable any more by the descriptor. 
     A feature descriptor should only be rotation invariant if significant in-plane rotation is expected to occur between the moving and the fixed image. In this respect, endoscopic image stitching poses a challenging hybrid scenario, since in-plane rotation is only significant for non-consecutive video frames. To detect corresponding features over a large amount of time, the descriptor needs to be invariant to rotation, while for consecutive video frames, rotation-invariance is not desirable. The straight-forward way of dealing with these mixed requirements is to calculate each feature descriptor twice—with and without normalized direction. This subsection presents a descriptor design to reduce this computational redundancy. It allows to quickly switch between a rotation-invariant and a non-rotation-invariant representation without the necessity to recalculate the descriptor from the image data. 
     The feature descriptor is represented as a binary vector encoding the intensity relation of pixel positions within the key point neighborhood. The order of bits is chosen according to sectors to achieve quick rotation normalization. The circular key point neighborhood is divided into T sectors. All bits, encoding a group of pixels from the same sector are located next to each other within the descriptor vector. Also, the spatial relations of the pixels of a sector are identical for all sectors. That way, the set of pixel groups is rotationally symmetric with regard to rotations of 360°/T. As a consequence, rotating the descriptor by an angle θ (0°≤θ360°) results in a circular shift operation of the bit vector by 
                     s   θ     =       ⌊       θ     360   ⁢   °       ⁢   T     ⌋     ·     N   T               (   27   )               
bits, with N being the length of the descriptor vector. If the reference direction θ (or its corresponding bit shift s θ ) is stored with each key point, a descriptor only needs to be calculated once and rotation invariance can be achieved at any time on demand. Normalizing its orientation may only use a simple circular bit shift operation. An additional advantage of this descriptor setup is the fact that no look-up table may be used to calculate a rotation normalized descriptor. Binary Robust Invariant Scalable Key Points (BRISK) and Fast Retina Key Points (FREAK) suggested look-up tables of 40 MB and 7 MB respectively, to implement rotation normalization [2], [4].
 
     In a further aspect the invention provides a camera system for producing in real-time a digital composite image, the camera system comprising: 
     a camera device configured for recording a sequence of digital images, in particular an endoscopic camera device configured for recording a sequence of digital images of an interior of a hollow structure; and 
     an image processing device according to the invention. 
     Furthermore, the invention provides a method for producing in real-time a digital composite image from a sequence of digital images recorded by a camera, in particular by an endoscopic camera, so that the composite image has a wider field of view than the images of the sequence of images, the method comprising the steps: 
     selecting a reference image and a further image from the sequence of images by using a selecting unit, wherein the reference image is specified in a global coordinate system of the composite image, wherein the further image is specified in a local coordinate system of the further image, and wherein the further image is overlapping the reference image;
 
detecting one or more global key points in the reference image and detecting one or more local key points in the further image by using a key point detection unit;
         wherein a filter response for the reference image and a filter response for the further image are produced by using a filter of the key point detection unit;   wherein the one or more global key points are detected by detecting local maxima in the filter response for the reference image and the one or more local key points are detected by detecting local maxima in the filter response for the further image by executing steps i) to iii) separately for the filter response for the reference image and for the filter response for the further image by using a maximum detection unit of the key point detection unit, wherein a variable threshold is used, wherein steps i) to iii) are defined as:   i) creating blocks by dividing the respective filter response,   ii) calculating the variable threshold,   iii) discarding those blocks of the blocks from further consideration, in which the respective filter response at a reference point of the respective block is less than the respective variable threshold;
 
transforming the further image into the global coordinate system by using a transforming unit based on at least one of the one or more global key points and based on at least one of the one or more local key points in order to produce a transformed further image; and
 
joining the reference image and the transformed further image in the global coordinate system by using a joining unit in order to produce at least a part of the composite image.
       

     Moreover, the invention provides a computer program for, when running on a processor, executing the method according to the invention. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Embodiments of the present invention will be detailed subsequently referring to the appended drawings, in which: 
         FIG. 1  illustrates an embodiment of an image processing device according to the invention in a schematic view; 
         FIG. 2  illustrates the functionalities of a maximum detection unit of an embodiment of an image processing device according to the invention in a schematic view; 
         FIG. 3  illustrates a key point detection unit of an embodiment of an image processing device according to the invention in a schematic view; 
         FIG. 4  illustrates a transforming unit of an embodiment of an image processing device according to the invention in a schematic view; and 
         FIG. 5  illustrates a feature descriptor calculated by a feature descriptor calculating unit of an embodiment of an image processing device according to the invention in a schematic view. 
     
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Equal or equivalent elements or elements with equal or equivalent functionality are denoted in the following description by equal or equivalent reference numerals. 
     In the following description, a plurality of details is set forth to provide a more thorough explanation of embodiments of the present invention. However, it will be apparent to one skilled in the art that embodiments of the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form rather than in detail in order to avoid obscuring embodiments of the present invention. In addition, features of the different embodiments described hereinafter may be combined with each other, unless specifically noted otherwise. 
       FIG. 1  illustrates an embodiment of an image processing device  1  according to the invention in a schematic view. 
     The image processing device  1  is configured for producing in real-time a digital composite image CI from a sequence SI of digital images recorded by a camera device  2 , in particular an endoscopic camera device  2 , so that the composite image CI has a wider field of view than the images of the sequence SI of images. The image processing device  1  comprises: 
     a selecting unit  3  configured for selecting a reference image RI and a further image FI from the sequence of images SI, wherein the reference image RI is specified in a global coordinate system of the composite image CI, wherein the further image FI is specified in a local coordinate system of the further image FI, and wherein the further image FI is overlapping the reference image RI;
 
a key point detection unit  4  configured for detecting one or more global key points GKP in the reference image RI and for detecting one or more local key points LKP in the further image FI,
         wherein the key point detection unit  4  comprises a filter  5  configured for producing a filter response FRI for the reference image RI and for producing a filter response FFI for the further image FI,   wherein the key point detection unit  4  comprises a maximum detection unit  6  configured for detecting the one or more global key points GKP by detecting local maxima in the filter response FRI for the reference image RI and for detecting the one or more local key points LKP by detecting local maxima in the filter response FFI for the further image FI by executing following steps separately for the filter response FRI for the reference image RI and for the filter response FFI for the further image FI, wherein a variable threshold VTR is used:   i) creating blocks BL by dividing the respective filter response FRI, FFI,   ii) calculating the variable threshold VTR,   iii) discarding those blocks BL of the blocks BL from further consideration, in which the respective filter response FRI, FFI at a reference point RP of the respective block BL is less than the respective variable threshold VTR;
 
a transforming unit  7  configured for transforming the further image FI into the global coordinate system based on at least one of the one or more global key points GKP and based on at least one of the one or more local key points LKP in order to produce a transformed further image TFI; and
 
a joining unit  8  configured for joining the reference image RI and the transformed further image TFI in the global coordinate system in order to produce at least a part of the composite image CI.
       

     According to an embodiment of the invention the maximum detection unit  6  is configured for executing following steps each time after executing step iii), wherein a constant threshold CTR is used: 
     iv) determining those blocks BL from the blocks BL not being discarded in step iii), in which the respective filter response FRI, FFI at the reference point RP of the respective block BL exceeds the constant threshold CTR, 
     v) comparing for the determined blocks BL the respective filter response FRI, FFI at the reference point RP with the respective filter response FRI, FFI at points AP adjacent to the reference point RP in order to determine whether one of the local maxima is detected at the reference point RP. 
     According to an embodiment of the invention the maximum detection unit  6  is configured for executing following steps each time after executing step iii) until a truncation condition occurs: 
     vi) creating blocks BL by dividing the blocks BL not being discarded in step iii), 
     vii) executing of steps ii to vi for the blocks BL created in step vi). 
     According to an embodiment of the invention the maximum detection unit  6  is configured for dividing the filter response FRI, FFI in step i) as a function of a scale level and a number of levels per octave in such way that the blocks BL all have a same size. 
     According to an embodiment of the invention the maximum detection unit  6  is configured for creating the blocks BL in step vi) in such way that the size of the blocks BL not being discarded in step iii is divided in halves for all dimensions. 
     According to an embodiment of the invention the maximum detection unit  6  is configured for calculating the variable threshold VTR in step ii) as a function of a dimension of the blocks BL, a size of the filter  5  and the constant threshold CTR. 
     According to an embodiment of the invention the maximum detection unit  6  is configured for using a central point of the respective block BL as the reference point RP of the respective block BL in step iii). 
     According to an embodiment of the invention the filter  5  is configured in such way that each of the filter response FRI for the reference image RI and the filter response FFI for the further image FI is equivalent to an absolute difference of two smoothing filter responses of the respective image RI, FI at different levels of a scale space. 
     According to embodiment of the invention each of the two smoothing filter responses is a parabolic filter response. 
     In another aspect the invention provides a camera system for producing in real-time a digital composite image CI, which comprises: 
     a camera device  2  configured for recording a sequence SI of digital images, in particular an endoscopic camera device  2  configured for recording a sequence of digital images of an interior of a hollow structure; and 
     an image processing device  1  according to the invention. 
     In a further aspect the invention provides a method for producing in real-time a digital composite image CI from a sequence SI of digital images recorded by a camera device  2 , in particular by an endoscopic camera device  2 , so that the composite image CI has a wider field of view than the images of the sequence SI of images, the method comprising the steps: 
     selecting a reference image RI and a further image FI from the sequence SI of images by using a selecting unit  3 , wherein the reference image RI is specified in a global coordinate system of the composite image CI, wherein the further image FI is specified in a local coordinate system of the further image FI, and wherein the further image FI is overlapping the reference image RI;
 
detecting one or more global key points GKP in the reference image RI and detecting one or more local key points LKP in the further image FI by using a key point detection unit  4 ;
         wherein a filter response FRI for the reference image RI and a filter response FFI for the further image FI are produced by using a filter  5  of the key point detection unit  4 ,   wherein the one or more global key points GKP are detected by detecting local maxima in the filter response FRI for the reference image RI and the one or more local key points LKP are detected by detecting local maxima in the filter response FFI for the further image FI by executing steps i to iii separately for the filter response RFI for the reference image RI and for the filter response FFI for the further image FI by using a maximum detection unit  6  of the key point detection unit  4 , wherein a variable threshold VTR is used, wherein the steps i) to iii) are defined as:   i) creating blocks BL by dividing the respective filter response FRI, FFI,   ii) calculating the variable threshold VTR,   iii) discarding those blocks BL of the blocks BL from further consideration, in which the respective filter response FRI, FFI at a reference point RP of the respective block BL is less than the respective variable threshold VTR;
 
transforming the further image FI into the global coordinate system by using a transforming unit  7  based on at least one of the one or more global key points GKP and based on at least one of the one or more local key points LKP in order to produce a transformed further image TFI; and
 
joining the reference image RI and the transformed further image TFI in the global coordinate system by using a joining unit  8  in order to produce at least a part of the composite image CI.
       

     In a further aspect the invention provides a computer program for, when running on a processor, executing the method according to the invention. 
       FIG. 2  illustrates the functionalities of a maximum detection unit  6  of an embodiment of an image processing device  1  according to the invention in a schematic view. The maximum detection unit  6  is configured for detecting one or more global key points GKP by detecting local maxima in the filter response FRI for the reference image RI and for detecting the one or more local key points LKP by detecting local maxima in the filter response FFI for the further image FI by executing steps i) to iii), and optionally iv) to vii), separately for the filter response FRI for the reference image RI and for the filter response FFI for the further image FI. The steps i) to vii) are conducted in the same way for the reference image RI and for the further image FI so that they are explained in the following only once. 
     The filter response, which is the filter response FRI for a reference image RI or the filter response FFI for a further image FI, and the blocks BL are shown for a simplified two-dimensional case. In practice the respective filter response RFI, FFI and the blocks BL usually are three-dimensional. 
     In step i) the respective filter response FRI, FFI is divided into four blocks BL 1  to BL 4 . Then, a variable threshold VTR having an exemplary value of t=4 is calculated for the blocks BL 1  to BL 4  in step ii). After that, the values R of the respective filter response FRI, FFI at the reference point RP of each of the blocks BL 1  to BL 4  is determined. In the example of  FIG. 2  the values are: R=3.8 for block BL 1 , R=4.2 for block BL 2 , R=6.5 for block BL 3  and R=4.2 for block BL 4 . As the variable threshold VTR has a value of t=4 the values R of the respective filter response FRI, FFI at the reference point RP of blocks BL 1  and BL 4  are less than the variable threshold VTR so that blocks BL 1  and BL 4  are discarded from further consideration. In other words, no further actions will be taken in order to find local maxima in blocks BL 1  and BL 4 . 
     In step iv) the values R of the remaining blocks BL 2  and BL 3  are compared to a constant threshold CTR, which has an exemplary value of T=6. As the value R of block BL 3  exceeds the constant threshold CTR, a local maxima search is conducted by comparing the value of the filter response at the reference point RP with the values of the respective filter response at points AP adjacent to the reference point RP in step v). 
     As blocks BL 2  and BL 3  have not been discarded in step iii), block BL 2  is divided in order to create blocks BL 21 , BL 22 , BL 23  and BL 24  and block BL 3  is divided in order to create blocks BL 31 , BL 32 , BL 33  and BL 34  in step vi). 
     In step vii) the blocks BL 21 , BL 22 , BL 23 , BL 24 , BL 31 , BL 32 , BL 33  and BL 34  are processed by repeating the steps ii) to vi). 
       FIG. 3  illustrates a key point detection unit  4  of an embodiment of an image processing device  1  according to the invention in a schematic view. 
     According to an embodiment of the invention the key point detection unit  4  comprises an integral image calculator  9  configured for calculating a reference integral image RII from the reference image RI and a further integral image FII from the further image FI, wherein the filter response FRI for the reference image RI is produced by feeding the reference integral image RII to the filter  5  and wherein the filter response FFI for the further image FI is produced by feeding the further integral image FII to the filter  5 . 
       FIG. 4  illustrates a transforming unit  7  of an embodiment of an image processing device  1  according to the invention in a schematic view. 
     According to an embodiment of the invention the transforming unit  7  comprises 
     a feature descriptor calculating unit  10  configured for calculating for each global key point GKP a global feature descriptor GFD characterizing a regional neighborhood RNH of the respective global key point GKP and for calculating for each local key point LKP a local feature descriptor LFD characterizing a regional neighborhood RNH of the respective local key point LKP;
 
a descriptor matching unit  11  configured for comparing the one or more local feature descriptors LFD with the one or more global feature descriptors GFD in order to identify matching features in the reference image RI and in the further image FI; and
 
an transforming execution unit  12  configured for transforming the further image FI into the global coordinate system based on the matching features in order to produce the transformed further image TFI;
 
wherein the feature descriptor calculating unit  10  is configured in such way that the one or more global feature descriptors GFD characterizing the regional neighborhood RNH of the respective global key point GKP and the one or more local feature descriptors LFD characterizing the regional neighborhood RNH of the respective local key point LKP each are represented by a bit vector BV;
 
wherein each bit of the respective bit vector BV encodes a characteristic of a pixel position PP in the respective regional neighborhood RNH;
 
wherein the respective regional neighborhood RNH is divided into sectors SE of a same size;
 
wherein each sector SE comprises a group of the pixel positions PP;
 
wherein the groups are arranged rotationally symmetric with regard to rotations around the respective key point GKP, LKP with a rotation angle, which is equal to a central angle CA of the sectors SE or a multiple of the central angle CA of the sectors SE; and
 
wherein all bits of the bit vector BV are arranged in such order that a bit shift operation of the bit vector BV, in which a number of the shifted bits is equal to a number of bits per group, is equivalent to a rotation of the respective regional neighborhood RNH by the central angle CA.
 
       FIG. 5  illustrates a feature descriptor GFD, LFD calculated by a feature descriptor calculating unit  10  of an embodiment of an image processing device  1  according to the invention in a schematic view. 
     The bit vector BV shown in  FIG. 5  and may represent either a global feature descriptor GFD for a global key point GKP or a local feature descriptor LFD for local key point LKP. 
     The regional neighborhood RNH of the respective key point GKP, LKP is, as an example, divided into eight sectors SE. Each of the sectors SV has an exemplary central angle CA of 45° and, thus, the same size. Each sector comprises, as an example, a group of two pixel positions PP. The groups of pixel positions PP are arranged rotationally symmetric with regard to rotations around the respective key point GKP, LKP with a rotational angle, which is equal to 45° or a multiple of 45°. 
     Audit bits of the bit vector BV are arranged in such order that the bit shift operation of the bit vector BV in which the number of shifted bits is two is equivalent to a rotation of the regional neighborhood RNH by 45°. 
     Depending on certain implementation requirements, embodiments of the inventive device and system can be implemented in hardware and/or in software. The implementation can be performed using a digital storage medium, for example a floppy disk, a DVD, a Blu-ray Disc, a CD, a ROM, a PROM, an EPROM, an EEPROM or a FLASH memory, having electronically readable control signals stored thereon, which cooperate (or are capable of cooperating) with a programmable computer system such that one or more or all of the functionalities of the inventive device or system is performed. 
     In some embodiments, a programmable logic device (for example a field programmable gate array) may be used to perform one or more or all of the functionalities of the devices and systems described herein. In some embodiments, a field programmable gate array may cooperate with a microprocessor in order to perform one or more or all of the functionalities of the devices and systems described herein. 
     Although some aspects have been described in the context of an apparatus, it is clear that these aspects also represent a description of the corresponding method, where a block or device corresponds to a method step or a feature of a method step. Analogously, aspects described in the context of a method step also represent a description of a corresponding block or item or feature of a corresponding apparatus. 
     Depending on certain implementation requirements, embodiments of the inventive method can be implemented using an apparatus comprising hardware and/or software. The implementation can be performed using a digital storage medium, for example a floppy disk, a DVD, a Blu-ray Disc, a CD, a ROM, a PROM, an EPROM, an EEPROM or a FLASH memory, having electronically readable control signals stored thereon, which cooperate (or are capable of cooperating) with a programmable computer system such that the respective method is performed. 
     Depending on certain implementation requirements, embodiments of the inventive method can be implemented using an apparatus comprising hardware and/or software. 
     Some or all of the method steps may be executed by (or using) a hardware apparatus, like a microprocessor, a programmable computer or an electronic circuit. Some one or more of the most important method steps may be executed by such an apparatus. 
     Some embodiments according to the invention comprise a data carrier having electronically readable control signals, which are capable of cooperating with a programmable computer system such that one of the methods described herein is performed. 
     Generally, embodiments of the present invention can be implemented as a computer program product with a program code, the program code being operative for performing one of the methods when the computer program product runs on a computer. The program code may for example be stored on a machine readable carrier. 
     Other embodiments comprise the computer program for performing one of the methods described herein, which is stored on a machine readable carrier or a non-transitory storage medium. 
     A further embodiment comprises a processing means, for example a computer, or a programmable logic device, in particular a processor comprising hardware, configured or adapted to perform one of the methods described herein. 
     A further embodiment comprises a computer having installed thereon the computer program for performing one of the methods described herein. 
     Generally, the methods are advantageously performed by any apparatus comprising hardware and or software. 
     While this invention has been described in terms of several embodiments, there are alterations, permutations, and equivalents which fall within the scope of this invention. It should also be noted that there are many alternative ways of implementing the methods and compositions of the present invention. It is therefore intended that the following appended claims be interpreted as including all such alterations, permutations and equivalents as fall within the true spirit and scope of the present invention. 
     REFERENCES 
     
         
         [1] Motilal Agrawal, Kurt Konolige, and Morten Rufus Blas. CenSurE: Center Surround Extremas for Realtime Feature Detection and Matching. In David Forsyth, Philip Torr, and Andrew Zisserman, editors,  European Conference On Computer Vision  ( ECCV ), Lecture Notes in Computer Science, pages 102-115. Springer Berlin Heidelberg, 2008. 00255. 
         [2] A. Alahi, R. Ortiz, and P. Vandergheynst. FREAK: Fast Retina Keypoint. In  IEEE Conference on Computer Vision and Pattern Recognition  ( CVPR ), pages 510-517, 2012. 00264. 
         [3] Wolfgang Förstner and Eberhard Gülch. A fast operator for detection and precise location of distinct points, corners and centres of circular features. In  Intercommission Conference on Fast Processing of Photogrammetric Data  ( ISPRS ), pages 281-305, 1987. 00953. 
         [4] S. Leutenegger, M. Chli, and R. Y. Siegwart. BRISK: Binary Robust invariant scalable key points. In  IEEE International Conference on Computer Vision  ( ICCV ), pages 2548-2555, 2011. 00398. 
         [5] David G. Lowe. Distinctive Image Features from Scale-Invariant Keypoints.  International Journal of Computer Vision,  60(2):91-110, 2004. 21859. 
         [6] Alexander Neubeck and Luc Van Gool. Efficient Non-Maximum Suppression. In  International Conference on Pattern Recognition  ( ICPR ), volume 3, pages 850-855, 2006. 00075. 
         [7] Tuan Q. Pham. Non-maximum suppression using fewer than two comparisons per pixel. In  International Conference on Advanced Concepts for Intelligent Vision Systems  ( ACIVS ), pages 438-451. Springer Berlin Heidelberg, 2010. 00009.