# Patent

## Title
Method and apparatus of tile-based belief propagation

## Abstract

A method and apparatus of tile-based belief propagation are disclosed. An image is split into a number of tiles. Messages are iteratively generated within each of the tiles based on the messages from neighboring pixels to the tile at a previous iteration, wherein each message represents information of a state of the pixel. The generated messages for sending out of the tiles are stored. Labels are then determined based on the stored messages, wherein each label represents the state of the pixel.

## Background
CROSS-REFERENCE TO OTHER APPLICATIONS
The present application claims the benefit of U.S. Provisional Application No. 61/119,333 filed on Dec. 2, 2008, the complete subject matter of which is incorporated herein by reference in its entirety.


BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention generally relates to image processing, and more particularly to tile-based belief propagation.
2. Description of the Prior Art
Energy (or cost) minimization on a Markov Random Field (MRF) is commonly applied to assign an optimal label to each node (pixel or block of pixels) of a scene representation in computer vision or image processing. A label stands for a local quantity of the state (or status) of the node. For example, the label may stand for the depth value of the node, or may stand for either foreground or background. There are two energy terms in the energy minimization: a data term Ed and a smoothness term Es. The data term Ed penalizes the inconsistency between the labels and the observed data. In other words, for example, the data term Ed should be increased when the labels and the observed data are inconsistent and vice versa. The smoothness term Es favors the spatial coherence of the labels. In other words, for example, the smoothness term Es should be decreased when the neighboring labels are consistent and vice versa. The optimal labels {lp} are the labels that minimize the combination of these two energy terms,




  
    
      
        
          {
          
            l
            p
          
          }
        
        =
        
          arg
          ⁢
          
            
          
          ⁢
          min
          ⁢
          
            {
            
              
                
                  ∑
                  
                    p
                    ∈
                    P
                  
                
                ⁢
                
                  
                    E
                    d
                  
                  ⁡
                  
                    (
                    
                      l
                      p
                    
                    )
                  
                
              
              +
              
                
                  ∑
                  
                    
                      (
                      
                        p
                        ,
                        q
                      
                      )
                    
                    ∈
                    G
                  
                
                ⁢
                
                  
                    E
                    s
                  
                  ⁡
                  
                    (
                    
                      
                        l
                        p
                      
                      ,
                      
                        l
                        p
                      
                    
                    )
                  
                
              
            
            }
          
        
      
    
    
      
        (
        1
        )
      
    
  




where P is the set of all nodes and G is a specified neighborhood, such as the 4-nearest neighboring pixels.

Many algorithms have been proposed for finding the optimal label assignment as formulated in the energy minimization. Among the algorithms, belief propagation (BP) has become a popular technique for solving computer vision problems, such as stereo estimation and image denoising. The belief propagation has high potential for hardware implementation due to its high degree of parallelism and regularity of memory access. However, the belief propagation requires large amounts of memory and bandwidth, therefore forbidding straightforward hardware implementation.
As the original belief propagation could not be effectively implemented in hardware, a need has arisen to propose a modified belief propagation which has similar performance but with much lower bandwidth and memory requirements than the original BP algorithm.
SUMMARY OF THE INVENTION
In view of the foregoing, it is an object of the present invention to provide a tile-based belief propagation, which is more suitable for hardware implementation than the original belief propagation due to the substantially reduced memory and bandwidth consumption.
According to one embodiment of the present invention, an image is first split into a number of tiles. Messages are then iteratively generated by a message computing device (such as a parallel processor) within each of the tiles, based on the messages from neighboring pixels to the tile at a previous iteration, wherein each message represents information of a state of the pixel. The generated messages for sending out of the tiles are stored, for example, in a memory. Labels are finally determined in a belief decision device based on the stored messages, wherein each label represents the state of the pixel.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 shows a flow diagram of a tile-based belief propagation (BP) according to one embodiment of the present invention;
FIG. 2A shows a portion of an image, in which each tile is made of B×B pixels;
FIG. 2B schematically shows messages around the tile;
FIG. 2C schematically shows messages Mpqt being sent out of the tile;
FIG. 3A shows the tiles being processed in a raster scan order;
FIG. 3B shows the tiles being processed in an inverse-raster scan order;
FIG. 4 shows a simplified example in which the message Mpqt at iteration t from p to q is constructed using the messages from neighbors to p at iteration t−1;
FIG. 5 shows a simplified example in which the node p collects all messages from the neighbors to determine the best label;
FIG. 6 shows an apparatus of the tile-based belief propagation (BP) according to one embodiment of the present invention;
FIG. 7A shows a coarse-to-fine technique for computing the message according to one embodiment of the present invention; and
FIG. 7B shows that each node in the level 1 corresponds to a block of 2×2 nodes in the level 1+1.



DETAILED DESCRIPTION OF THE INVENTION
FIG. 1 shows a flow diagram of a tile-based belief propagation (BP) according to one embodiment of the present invention. The present invention may be applied in a variety of applications in image processing, such as, but not limited to, image denoising, stereo matching, motion estimation and depth generation. An exemplary pseudocode of the tile-based belief propagation is shown below.










pseudocode















Function {lp} ← TileBasedBP(Ed, Es, B, T0, Ti)


1   Initialize all message entities Mpq0(l)=0


2   for t0=1, . . . ,T0


3     loop through all tiles in a raster scan order


4       Load {Mpqt−1} for p ∉ C and q ε C; //C is the current


tile.


5       Load Ed(lp) for p ε C;


6       for ti=1, . . . ,Ti


7         {Mpqt} ← BPinOneTile({Mpqt−1}, Ed, C);


8       Store {Mpqt} for p ε C and q ∉ C;


9     loop through all tiles in an inverse-raster scan order


10       Load {Mpqt−1} for p ∉ C and q ε C;


11       Load Ed(lp) for p ε C;


12       for ti=1, . . . ,Ti


13         {Mpqt} ← BPinOneTile({Mpqt−1}, Ed, C);


14       if (t0=T0) Obtain {lp} for p ε C; //using Eq. (3);


15       else Store {Mpqt} for p ε C and q ∉ C;


16   return {lp};


Function {Mpqt} ← BPinOneTile({Mpqt−1}, Ed, C)


17   Initialize Mpqt(l)=0 for all p ε C and q ε C;


18     Update rightward message; //using Eq. (2);


19     Update leftward message;


20     Update downward message;


21     Update upward message;


22   return {Mpqt};









According to the embodiment, in step 10, the whole image is split into non-overlapping tiles of pixels. FIG. 2A shows a portion of an image, in which each tile is made of 4×4 pixels, while tile sizes other than 4×4 may be adapted as well. FIG. 2B schematically shows messages (i.e., the arrows) around the tile. The messages stand for information on the state (or status) of the outside world (that is, the pixels outside of the tile).
The pseudocode has a two-level structure: outer and inner iterations. In the outer iteration, the tiles are first processed in a raster scan order (beginning at line 3 of the pseudocode), and the tiles are then processed in an inverse-raster scan order (beginning at line 9 of the pseudocode). FIG. 3A shows the tiles being processed in the raster scan order (that is, from the top-left tile to the bottom-right tile), and FIG. 3B shows the tiles being processed in the inverse-raster scan order (that is, from the bottom-right tile to the top-left tile). It is appreciated that other scan orders may be adapted. For example, the tiles may be first processed in a vertically downward scan order from the left column to the right column, followed by a vertically upward scan order from the right column to the left column. Moreover, in certain situations, only partial tiles of the image are processed.
For each tile, the messages from other tiles (i.e., the arrows shown in FIG. 2B), the smoothness term Es and the data term Ed are loaded from the memory, and then a message computing operation is performed within the tile (in step 11) according to the following BP equation (2) (that is, the function BPinOneTile in the pseudocode).




  
    
      
        
          
            M
            pq
            t
          
          ⁡
          
            (
            
              l
              p
            
            )
          
        
        =
        
          
            min
            
              
                l
                ′
              
              ∈
              L
            
          
          ⁢
          
            {
            
              
                
                  E
                  s
                
                ⁡
                
                  (
                  
                    
                      l
                      q
                    
                    ,
                    
                      l
                      ′
                    
                  
                  )
                
              
              +
              
                
                  E
                  d
                
                ⁡
                
                  (
                  
                    l
                    ′
                  
                  )
                
              
              +
              
                
                  ∑
                  
                    
                      (
                      
                        p
                        ,
                        
                          p
                          ′
                        
                      
                      )
                    
                    ∈
                    
                      
                        N
                        p
                      
                      ⁢
                      \
                      ⁢
                      q
                    
                  
                
                ⁢
                
                  
                    M
                    
                      
                        p
                        ′
                      
                      ⁢
                      p
                    
                    
                      t
                      -
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      l
                      ′
                    
                    )
                  
                
              
            
            }
          
        
      
    
    
      
        (
        2
        )
      
    
  




where Np is the set of the neighbors of p.

Specifically, at iteration t, each node p sends the resultant message Mpqt to its neighbor q. Mpqt (1) encodes the opinion of p about assigning label 1q to q. The message Mpqt at iteration t from p to q is constructed using the messages from neighbors to p at iteration t−1. FIG. 4 shows a simplified example in which the message Mpqt at iteration t from p to q is constructed using the messages (Mrpt−1, Mspt−1 and Mupt−1) from neighbors (r, s and u) to p at iteration t−1.
After Ti inner iterations (lines 6-7 of the pseudocode), the messages Mpqt for sending out of the tile are stored (in step 12). FIG. 2C schematically shows the messages Mpqt (i.e., the arrows) being sent out of the tile. The inner iterations act like a filtering operation that purifies the messages according to the data terms and the smoothness terms within the tile.
As the tiles are processed in the raster/inverse-raster scan order, the messages are thus iteratively propagated. At the T0 outer iteration (that is, the end of the raster scan and the inverse-raster scan), the best labels are determined (in step 13) using the following equation (3) in line 14 of the pseudocode.




  
    
      
        
          l
          p
        
        =
        
          arg
          ⁢
          
            
          
          ⁢
          
            
              min
              
                l
                ∈
                L
              
            
            ⁢
            
              {
              
                
                  
                    E
                    d
                  
                  ⁡
                  
                    (
                    l
                    )
                  
                
                +
                
                  
                    ∑
                    
                      
                        (
                        
                          p
                          ,
                          
                            p
                            ′
                          
                        
                        )
                      
                      ∈
                      
                        N
                        ⁡
                        
                          (
                          p
                          )
                        
                      
                    
                  
                  ⁢
                  
                    
                      M
                      
                        
                          p
                          ′
                        
                        ⁢
                        p
                      
                      T
                    
                    ⁡
                    
                      (
                      l
                      )
                    
                  
                
              
              }
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




where L is the set of all labels.

After enough iterations, say T (a number), the label of node p is determined based on the local likelihood (i.e., the data term Ed) and the messages Mp′pT from the neighbors. FIG. 5 shows a simplified example in which the node p collects all messages from the neighbors (r, s, u and q) to determine the best label.
According to the embodiment, the BP has the following advantages for hardware implementation. First, it is highly parallel. In message passing, each node loads the messages from the previous iteration, operates independently, and generates new messages. Second, it only uses simple operations such as additions and comparisons. Third, the memory access is regular. If the message is updated sequentially, the required input data can be streamed into the processor with ease.
FIG. 6 shows apparatus 60 of the tile-based belief propagation (BP) according to one embodiment of the present invention. A message computing device 601, preferably a parallel processor, generates message {Mpqt} at iteration t according to the messages {Mpqt−1} from neighbors to p at iteration t−1, which are loaded from an (internal/external) memory 602. According to the tile architecture, the operations of the function BPinOneTile in the pseudocode may be preferably performed in a parallel manner within the parallel processor or the message computing device 601.
After Ti inner iterations (lines 6-7 of the pseudocode), the messages {Mpqt} for sending out of the tile are stored in the memory 602. Subsequently, at the T0 outer iteration, a belief decision device 603 determines the best labels {lp} based on the messages Mp′pT from the neighbors. Finally, an output device 604 generates a label map (such as a depth map or a motion vector map) according to the determined labels {lp}.
Table 1 compares the memory and bandwidth consumption of the original belief propagation and the tile-based belief propagation of the present embodiment.









TABLE 1






Original




BP
Tile-based BP




















Tile size (B2)

82
162
322
642













Internal
Data terms
16
1,024
4,096
16,384
65,536


memory
Messages
64
4,096
16,384
65,536
262,144



Total
80
5,120
20,480
81,920
327,680



Factor (to

100%
100%
 100%
  100%



the same








tile size)















External
Data terms
4,915,200
4,915,200













memory
Messages
19,660,800
2,457,600
1,228,800
614,400
307,200



Total
24,576,000
7,372,800
6,144,000
,5,529,600
5,222,400



Factor (to
100%
 30%
 25%
22.5%
21.25%



the same








tile size)







Bandwidth
Data terms
19,660,800







Messages
78,643,200
4,915,200
2,457,600
1,228,800
614,400



Total
98,304,000
9,830,400
7,372,800
6,144,000
5,529,600



Factor (to
100%
 10%
 7.5%
6.25%
5.625%



the same








tile size)









FIG. 7A shows a coarse-to-fine technique for computing the message according to one embodiment of the present invention. In the embodiment, level 2 has full resolution, level 1 has 1⁄4 resolution, and level 0 has 1/16 resolution. Each node in level 1 corresponds to a block of 2×2 nodes in level 1+1, as shown in FIG. 7B. At the beginning, a coarse computing is performed to run BP on level 0 for the smallest number of iterations. Subsequently, a finer computing is performed on the (level 1) 2×2 nodes corresponding to a single node of level 0. Each message between adjacent nodes on level 0 is duplicated to two messages for the two adjacent pair of nodes on level 1 as shown in FIG. 7B. Finally, a finest computing is performed on the (level 2) 2×2 nodes corresponding to a single node of the level 1.
Although specific embodiments have been illustrated and described, it can be appreciated by those skilled in the art that various modifications may be made without departing from the scope of the present invention, which is intended to be limited solely by the appended claims.

## Claims

1. A method of tile-based belief propagation, comprising:
splitting an image into a plurality of tiles each including a plurality of pixels;
iteratively generating messages within each of the tiles based on messages from neighboring pixels to the tile at a previous iteration, wherein each message represents information of a state of the pixel;
storing generated messages for sending out of the tiles; and
determining labels based on the stored messages, wherein each label represents the state of the pixel;
wherein the messages are generated further based on a data energy term Ed and a smoothness energy term Es in energy minimization on a Markov Random Field (MRF); and
wherein the step of iteratively generating messages within each of the tiles is performed according to a brief propagation (BP) equation:





  
    
      M
      pq
      t
    
    ⁡
    
      (
      
        l
        p
      
      )
    
  
  =
  
    
      min
      
        
          l
          ′
        
        ∈
        L
      
    
    ⁢
    
      {
      
        
          
            E
            s
          
          ⁡
          
            (
            
              
                l
                q
              
              ,
              
                l
                ′
              
            
            )
          
        
        +
        
          
            E
            d
          
          ⁡
          
            (
            
              l
              ′
            
            )
          
        
        +
        
          
            ∑
            
              
                (
                
                  p
                  ,
                  
                    p
                    ′
                  
                
                )
              
              ∈
              
                
                  N
                  p
                
                ⁢
                \
                ⁢
                q
              
            
          
          ⁢
          
            
              M
              
                
                  p
                  ′
                
                ⁢
                p
              
              
                t
                -
                1
              
            
            ⁡
            
              (
              
                l
                ′
              
              )
            
          
        
      
      }
    
  




in which Np is a set of neighbors of a pixel p,
Mpqt is the generated message at iteration t, and
Mp′pt−1 is the message at the previous iteration t−1.

2. The method. of claim 1, further comprising a step of generating a. label map according to the determined labels.

3. The method of claim 1, wherein the iterative steps of generating messages within each of the tiles are performed in a raster scan order.

4. The method. of claim. 3, further performing the iterative steps of generating messages within each of the tiles in an inverse-raster scan order.

5. The method of claim 1, wherein the iterative steps of generating messages within each of the tiles are performed on a portion of the image.

6. The method. of claim. 1, wherein the labels are determined further based on a data energy term Ed in energy minimization on a Markov Random Field (MRF).

7. The method of claim 6, wherein the step of determining labels is performed according to an equation:




  
    l
    p
  
  =
  
    arg
    ⁢
    
      
    
    ⁢
    
      
        min
        
          l
          ∈
          L
        
      
      ⁢
      
        {
        
          
            
              E
              d
            
            ⁡
            
              (
              l
              )
            
          
          +
          
            
              ∑
              
                
                  (
                  
                    p
                    ,
                    
                      p
                      ′
                    
                  
                  )
                
                ∈
                
                  N
                  ⁡
                  
                    (
                    p
                    )
                  
                
              
            
            ⁢
            
              
                M
                
                  
                    p
                    ′
                  
                  ⁢
                  p
                
                T
              
              ⁡
              
                (
                l
                )
              
            
          
        
        }
      
    
  




where L is a set of all labels l, and
Mp′pT is the message after a specified number of iterations T.

8. The method. of claim 1, wherein, the iterative generating of messages is performed on at least a first level and a second level, wherein each node in the first level corresponds to a block of a plurality of nodes in the second level, wherein each of the nodes includes one or more pixels.

9. The method of claim 8, wherein the iterative generating of messages is performed on the first level, followed by being performed on the second level.

10. The method of claim 9, wherein each message between or among adjacent nodes on the first level is duplicated into a plurality of messages for the adjacent pairs of nodes on the second level.

11. An apparatus of tile-based belief propagation, comprising:
means for splitting an image into a plurality of tiles each including a plurality of pixels;
a message computing device for iteratively generating messages within. each of the tiles based on messages from neighboring pixels to the tile at a previous iteration, wherein each message represents information of a state of the pixel;
a memory for storing generated messages for sending out of the tiles; and
a belief decision device for determining labels based on the stored messages, wherein each label represents the state of the pixel;
wherein the messages are generated in the message computing device further based on a data energy term Ed and a smoothness energy term Es in energy minimization on a Markov Random Field (MRF); and
wherein the messages are generated in the message computing device according to a brief propagation (BP) equation:





  
    
      M
      pq
      t
    
    ⁡
    
      (
      
        l
        p
      
      )
    
  
  =
  
    
      min
      
        
          l
          ′
        
        ∈
        L
      
    
    ⁢
    
      {
      
        
          
            E
            s
          
          ⁡
          
            (
            
              
                l
                q
              
              ,
              
                l
                ′
              
            
            )
          
        
        +
        
          
            E
            d
          
          ⁡
          
            (
            
              l
              ′
            
            )
          
        
        +
        
          
            ∑
            
              
                (
                
                  p
                  ,
                  
                    p
                    ′
                  
                
                )
              
              ∈
              
                
                  N
                  p
                
                ⁢
                \
                ⁢
                q
              
            
          
          ⁢
          
            
              M
              
                
                  p
                  ′
                
                ⁢
                p
              
              
                t
                -
                1
              
            
            ⁡
            
              (
              
                l
                ′
              
              )
            
          
        
      
      }
    
  




with Np being a set of neighbors of a pixel p,
Mpqt being the generated message at iteration t, and
Mp′pt−1, the message at the previous iteration t−1.

12. The apparatus of claim 11, further comprising an output device for generating a label map according to the determined labels.

13. The apparatus of claim 11, wherein the messages are generated in the message computing device in a raster scan order.

14. The apparatus of claim 13, wherein the messages are generated in the message computing device further in an inverse-raster scan order.

15. The apparatus of claim 11, wherein the message computing device is a parallel processor.

16. The apparatus of claim 11, wherein the labels are determined in the belief decision device further based on a data energy term Ed in energy minimization on a Markov Random Field (MRF).

17. The apparatus of claim 16, wherein the labels are determined in the belief decision device according to an equation:




  
    l
    p
  
  =
  
    arg
    ⁢
    
      
    
    ⁢
    
      
        min
        
          l
          ∈
          L
        
      
      ⁢
      
        {
        
          
            
              E
              d
            
            ⁡
            
              (
              l
              )
            
          
          +
          
            
              ∑
              
                
                  (
                  
                    p
                    ,
                    
                      p
                      ′
                    
                  
                  )
                
                ∈
                
                  N
                  ⁡
                  
                    (
                    p
                    )
                  
                
              
            
            ⁢
            
              
                M
                
                  
                    p
                    ′
                  
                  ⁢
                  p
                
                T
              
              ⁡
              
                (
                l
                )
              
            
          
        
        }
      
    
  




where L is a set of all labels l, and
Mp′pT is the message after a specified number of iterations T.

18. The apparatus of claim 11, wherein the generating of messages is performed on at least a first level and a second level, wherein each node in the first level corresponds to a block of a plurality of nodes in the second level, wherein each of the nodes includes one or more pixels.

19. The apparatus of claim 18, wherein the generating of messages is performed on the first level, followed by being performed on the second level.

20. The apparatus of claim 19, wherein each message between or among adjacent nodes on the first level is duplicated into a plurality of messages for the adjacent pairs of nodes on the second level.

21. A method of tile-based belief propagation, comprising:
splitting an image into a plurality of tiles each including a plurality of pixels;
iteratively generating messages within each of the tiles based on messages from neighboring pixels to the tile at a previous iteration, wherein each message represents information of a state of the pixel;
storing generated messages for sending out of the tiles; and
determining labels based on the stored messages, wherein each label represents the state of the pixel;
wherein the labels are determined further based on a data energy term Ed in energy minimization on a Markov Random Field (MRF); and
wherein the step of determining labels is performed according to an equation:





  
    l
    p
  
  =
  
    arg
    ⁢
    
      
    
    ⁢
    
      
        min
        
          l
          ∈
          L
        
      
      ⁢
      
        {
        
          
            
              E
              d
            
            ⁡
            
              (
              l
              )
            
          
          +
          
            
              ∑
              
                
                  (
                  
                    p
                    ,
                    
                      p
                      ′
                    
                  
                  )
                
                ∈
                
                  N
                  ⁡
                  
                    (
                    p
                    )
                  
                
              
            
            ⁢
            
              
                M
                
                  
                    p
                    ′
                  
                  ⁢
                  p
                
                T
              
              ⁡
              
                (
                l
                )
              
            
          
        
        }
      
    
  




where L is a set of all labels l, and
Mp′pT is the message after a specified number of iterations T.