Abstract:
A method is proposed for segmenting a 2- or 3-D space, spanned by a set of medical data comprising intensity values at locations within the space, to estimate the position of an object of medical significance. The method using a level set function having a level set which provides a model of boundary of the object. The level set function is iteratively updated by a force defined based on the medical data. For computational efficiency, only the force in the narrowband of the model boundary needs to be calculated. Minimization of an energy function, related to the force, provides a termination condition for the iteration. High level knowledge can be incorporated in several ways, such as by an explicit force term which takes over from the force based on the medical data when prior knowledge of the object is about to be violated by the model.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application is a U.S. National Phase Application of PCT International Application No. PCT/SG2007/000275, filed on Aug. 24, 2007, which claims the benefit of U.S. Application Ser. No. 60/839,684, filed on Aug. 24, 2006, both of which are expressly incorporated by reference herein. 
    
    
     FIELD OF THE INVENTION 
     The present invention relates to a method and system for segmenting a space spanned by a set of medical data, such as a 2- or 3-dimensional MRI image of at least part of a brain or other structure consisting of a set of intensity values at corresponding locations in the space. The segmentation produces a model of an object having medical significance, that is an estimate of the portion of the space occupied by the object. 
     BACKGROUND OF THE INVENTION 
     Since their introduction by Kass et al. (Kass 1988), a variety of deformable models have been proposed and used in a numerous areas such as image segmentation, shape modeling, and object tracking. Existing deformable models can be classified as either parametric deformable models (PDMs) (Kass, 1988; Cohen, 1991; Xu, 1998; McInery, 1996; Cottes, 1991, 2001; Shen, 2001; Liu, 2005) or geometric deformable models (GDMs) (Malladi, 1995; Caselles, 1997; Yezzi, 1997; Sethian, 1999; Han, 2003) according to their representation and implementation. In particular, PDMs are represented explicitly as parameterized curves or surfaces in a Lagrangian formulation. GDMS, on the other hand, are represented implicitly as level sets of higher-dimensional level set functions. That is, to model a contour within a 2-D space, or a surface within a 3-D space, we define a continuous function (a level set function) which takes a certain value (e.g. zero) on the contour or surface (referred to as the “level set”), and a non-zero value elsewhere. The level set function evolves according to an Eulerian formulation (Sethian 1999). 
     GDMs are superior to PDMs in the following aspects: 
     Model representation and construction. GDMs are completely intrinsic and independent of the parameterization of the evolving contour. Thus, there is no need to add or remove nodes from the initial parameterization or adjust the spacing of the nodes. For PDMs, particularly, in the 3D cases, it is not a trivial task to generate parameterized representations for surface models. 
     Model property calculation. The intrinsic geometric properties of a geometric deformable model, such as its normal and curvature, can be easily determined from the level set function. 
     Shape adaptation. In GDMs, the propagating contour or surface can automatically change its topology (e.g., merge or split) without requiring an elaborate mechanism to handle such changes. 
     Self-intersection detection. When the topology preserving transformations are required for a deformable model, self-intersections can become a problem. In GDMs, digital topology methods (Bertrand 1994) are available to detect self-intersections, while in PDMs, the computational demands related to self-intersection detection are usually very high (MacDonald 2000). 
     On the contrary, PDMs have the following merits over GDMs: 
     Model constraints. Since PDMs are represented globally, it is convenient to add high level constraints on shape and topology. These constraints are particularly important when local features of the model and image are liable to deform the model in unexpected ways. 
     Leakage prevention. Leakage from the boundary is less common in PDMs, whereas it is sensitive to boundary gaps and weak edges in GDMs. 
     Convergence detection. The deformation procedures in PDMs have an explicit stop condition which is the minimization of some kinds of energy function, whereas in GDMs, the procedure usually stops when the certain number of iterations reaches a predetermined maximum, but no simple and fast methods are available to automatically estimate a suitable maximum number of iterations. 
     SUMMARY OF THE INVENTION 
     The present invention aims to provide new and useful ways to estimate, within a space spanned by a set of medical data (e.g. MRI data consisting of intensity values at many corresponding locations in a two- or three-dimensional space), the portion of the space occupied by an object. 
     In general terms, the present invention proposes a boundary-based geometrical deformable model (BGDM). That is, a model is represented by a level set function, which is modified by force calculated using the medical data and the boundary of the model. 
     Thus, in a way similar to traditional geometrical deformable models, the invention employs a model which is embedded in a level set of a higher-dimensional function, while in a way similar to the traditional parametric deformable models, the deformation of the model is calculated by force on its boundary. 
     The convergence condition used for termination of the iteration may be the minimization of an energy function related to the force. Thus, the embodiments of the invention may have the convergence advantages of PDMs. 
     The force used to deform the level set function may be calculated at each point of a narrowband region (neighbourhood) of the level set, and the level set function modified only at these locations. This reduces the computational burden, compared to modifying the entire level set function in all iterations. Upon detecting that the level set approaching the boundary of the narrowband region, portions of level set function outside the narrowband region may be refreshed. 
     The narrowband may include two sets of locations (pixels in a 2D space or voxels in a 3D space): first locations at the boundary of the model (level set) and second locations in a neighbourhood of the boundary (“narrowband region”). The force at the first locations is calculated using the medical data, and the force at the second locations is calculated using the calculated force at the first locations. Specifically, around each of the second locations a neighbourhood may be defined, and the force at the second locations can be found by reference to the force at those first locations which are within the neighbourhood. It has been found that this use of neighbourhoods reduces (or even avoids) the leakage problem (in which the object may wrongly grow to other regions of the space). 
     High level knowledge about the object can be incorporated in any one or more of several ways. First, it may be used in the definition of the force which modifies the level set function (e.g. such that when it appears that a predetermined fact about the object is to be contravened by the modification, the force switches from being one based on the medical data to one which incorporates the prior knowledge). Secondly, it may be used to choose the exact form of the force which is calculated using the medical data. Thirdly, the modification of the level set function may only be performed when this does not violate some prior knowledge of the object. 
     The force which is calculated using the medical data may be a “gradient flux”-based force, which is a function of the gradient of intensity values of the medical data. The gradient flux-based force at each point on the level set may be obtained efficiently by searching along a line segment passing through that point and normal to the level set at that point, for a location which maximises the value of a gradient flux density which is a function of the gradient of the intensity values (or more generally, a location which is a stationary point of the gradient flux density). In a manner inspired by electromagnetic systems, the gradient flux density may vary as a linear function of the gradient of the intensity values divided by a linear function of the square of the distance of the location from the level set (i.e. analogous to an inverse square law). The energy function may be average of the gradient flux density over the level set. 
     One specific expression of the invention is a method of image segmentation and modelling, within a space spanned by a set of medical data, the portion of the space occupied by an object, the method comprising: 
     (a) defining a level set function, a level set of the level set function being the boundary of a deformable model of the object; 
     (b) iteratively performing at least once the set of steps:
         (i) calculating, at each of a plurality of locations, a corresponding force, said force being calculated using the medical data and the boundary of the model; and   (ii) modifying the level set function at the plurality of locations according to the corresponding calculated forces; and       

     (c) modelling the boundary of the said object as the level set of the modified level set function. 
     However, the invention may alternatively be expressed as a computer system arranged to carry out this method, or as a computer program product (i.e. software) which when run by a computer causes the computer to carry out the method. 
    
    
     
       DESCRIPTION OF THE DRAWINGS 
       An embodiment of the invention will now be described for the sake of example only with reference to the following figures, in which: 
         FIG. 1  shows schematically the calculation of the gradient flux density at a boundary point x of the model in an embodiment of the invention; 
         FIG. 2  shows segmentation results using the embodiment for orbital muscles in MR image: a) original image, b) the initial position of five numbered contours, b) final positions obtained by deforming each of the initial contours iteratively using the embodiment; and 
         FIG. 3  is a flow diagram of the steps of the embodiment. 
     
    
    
     DETAILED DESCRIPTION OF EMBODIMENTS 
     1. Overview of Embodiment 
     An embodiment of the invention will now be described with reference to  FIGS. 1 to 3 . This embodiment is used for the segmentation of a medical dataset which is a set of intensity values, such as an MR image. The intensity values are associated with respective points in a two- or three-dimensional space. The segmentation identifies an object within the image. Specific examples are given of the use of the embodiment for segmenting orbital muscles within MR images, but application of the embodiment to other segmentations tasks is straightforward. 
     The embodiment employs an initial model which is defined in the space of the image. If the space of the image is 2D, the initial model is a contour represented polygon, or, if the space of the image is 3D, the model is a surface represented by triangle meshes. The contour or surface forms one or more closed inside regions which indicate object itself. The model is chosen manually based on the prior-knowledge of the object&#39;s shape and size, and initially located according the location of the object in the image. This model is then allowed to evolve, according to equations defined below, within the space of the image to form a final model which is the estimate of the position of the object. 
     Positions in the space are denoted by a vector x. The initial model is expressed as a zero level set of a higher dimensional level set function φ(x,t), defined as follows. The initial value of φ(x,t) at time t=0, that is φ(x,0), is defined as the signed Euclidian distance map (Maurer 2003) of the model: with negative value inside the model, and positive outide the model. The evolution of the function φ(x,t) is governed by the following equation:
 
φ t ( x,t )=− n ( x,t )· f ( x,t )  (1)
 
where, φ t (x,t) denotes the time derivative of φ(x, t), f(x,t) denotes the total force which is a function of the model at time t and of the image dataset (explicit expressions for f(x, t) are given below), and n(x, t) is the unit normal of the level set, i.e. the unit vector which is defined by:
 
 n ( x,t )=∇φ( x,t )/|∇φ( x,t )|.  (2)
 
     The numerical solution of Equation (1) is obtained by approximating the real time variable t by a series of discrete time t i =i·Δt, where i=0, 1, 2, . . . and the time step is denoted as Δt. The functions φ t (x,t), n(x,t) and f(x,t) can be approximated as φ(x,t i ), n(x,t i ) and f(x,t i ) respectively. The time derivative φ t (x,t) is approximated as the difference between the respective values of φ(x,t i ) at two successive time steps, divided by Δt. The spatial derivative on the right hand side of (2) is treated by upwind numerical schemes (Sethian, 1999), which gives:
 
φ( x,t   t+1 )=φ( x,t   i )−Δ t·n ( x,t   i )· f ( x,t   i )( i= 0,1,2, . . . ).  (3)
 
     To describe the evaluation state of the deformable model at a given time t, we introduce several notations:
         s(x,t): the sign of the function φ(x,t), i.e.:       

     
       
         
           
             
               
                 
                   
                     s 
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         t 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           1 
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 ϕ 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     x 
                                     , 
                                     t 
                                   
                                   ) 
                                 
                               
                             
                             ≤ 
                             0 
                           
                         
                       
                       
                         
                           
                             - 
                             1 
                           
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 ϕ 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     x 
                                     , 
                                     t 
                                   
                                   ) 
                                 
                               
                             
                             &gt; 
                             0 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
         
         
           
             Ω(t): the region occupied by the deformable model, i.e.:
 
Ω( t )={ x|s ( x,t )=1}  (5)
 
           
         
       
    
     That is, the set of all locations x such that φ(x, t) is at least zero.
         ∂(t): the boundary of the region Ω(t), i.e. the set of all locations such that φ(x,t)=0.   b r (t): the “narrowband” of the boundary ∂(t), which is defined as the set of points with Euclidean distance to ∂(t) less than a given threshold r.   #(S): the cardinal number which is equal to the number of discrete points in a given set S.       

     2. Gradient Flux 
     We now turn to the problem of defining f(x,t i ). To do so, we first define a novel function called the “gradient flux”. 
     To begin with, according to the object we are trying to model, we define a “gradient characteristic number” g, which describes the gradient direction at a boundary of the object. In general terms, we select g according to whether the desired object is a valley of the intensity (g=1), or a peak of the intensity (g=−1). If the desired object is neither of these things, such as a saddle-point of the intensity, we select g=0. More specifically, if the object is such that all gradients on the object boundary point to the outside, g is set to 1. If all gradients on the objection boundary point to the inside, g is set to −1. Otherwise, g is set to 0. For example, in a T1 MR orbital image, g is 1 for orbital muscles; in T1 MR human brain images, g is 1 for the hippocampus, −1 for ventricles, and 0 for caudate nuclei. 
     Now we define the “gradient flux” as follows. This is intended to produce the result that the nearer the boundary of the model is to that of the object in the image, the larger the average gradient flux on the boundary of the model. Referring to  FIG. 1 , we denote the boundary ∂(t) of the model at time t by reference numeral  1 . Thus, the model at this time is the region Ω(r) to the left of the model boundary  1 . The (unknown) boundary of the object which is to be identified by the segmentation technique is denoted by reference numeral  3 . 
     Consider a point  5  on the boundary  1 . The point  5  has coordinate x, and the normal direction to the boundary at this point is shown on  FIG. 1  as n(x,t). We will define the gradient flux at point  5  such that only the corresponding point in the image contributes to the gradient flux at point x. The corresponding point on the image is defined in such a way that it requires little computing cost to find it. Specifically, it is defined as a point on the line segment which has its centre at point x and extends in direction n(x,t) to a predefined length d outside of the boundary ∂(t), and in direction −n(x,t) to a predetermined length d inside the boundary. Thus, to find this corresponding point we only have to search along this line segment, which is relatively computationally cheap. Any point on the line segment has coordinates x+r·n(x,t), and denoting the intensity value of the image dataset at this point on the line segment as I(x+r·n(x,t), the gradient vector of the image intensity at this point can be written as ∇I(x+r·n(x,t)). It is expected that the point  7  at which the line segment intersects with the object boundary  3  is such that ∇I(x+r·n(x,t)) is a local maximum. Furthermore, ∇I(x+r·n(x,t)) should be consistent with the expected direction: if the gradient characteristic number g of the object is 1, then the gradient vector ∇I(x+r·n(x,t)) should point to the outside of the model; and if the gradient characteristic number g is −1, then the gradient vector ∇I(x+r·n(x,t)) should point to the inside of the model. 
     To give a numerical value to the gradient flux, suppose that a point charge were located at point x+r·n(x,t). Thus, the electric flux density at point x would decrease with the distance r according to the function 3/(4πr 2 ). By analogy, we will define the gradient flux density at any point along the line segment such that the gradient flux decreases with the distance to the boundary in the same way as the electric flux. In order to avoid the gradient flux becoming infinite for r=0, we define the gradient flux using the function 3/(4πr 2 +1) instead of 3/(4πr 2 ), so that gradient flux is defined at r=0. 
     According to these heuristic rules, the embodiment calculates the gradient flux density e(x, n(x, t)) at any model boundary point  5  having location x as: 
     
       
         
           
             
               
                 
                   
                     e 
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         
                           n 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               , 
                               t 
                             
                             ) 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       max 
                       
                         
                            
                           r 
                            
                         
                         ≤ 
                         d 
                       
                     
                     ⁢ 
                     
                       { 
                       
                         
                           
                             3 
                             
                               
                                 4 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 π 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   r 
                                   2 
                                 
                               
                               + 
                               1 
                             
                           
                           ⁢ 
                           
                             ξ 
                             ( 
                             
                               g 
                               , 
                               
                                 n 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     x 
                                     , 
                                     t 
                                   
                                   ) 
                                 
                               
                               , 
                               
                                 ∇ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   I 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       x 
                                       + 
                                       
                                         r 
                                         · 
                                         
                                           n 
                                           ⁡ 
                                           
                                             ( 
                                             
                                               x 
                                               , 
                                               t 
                                             
                                             ) 
                                           
                                         
                                       
                                     
                                     ) 
                                   
                                 
                               
                             
                             } 
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
     where n(x, t) denotes the outside normal of the model boundary  1  at point x; ∇I(x+r·n(x,t)) is the gradient of the image at x+r·n(x,t); d is the predefined maximum search length; the function ξ indicates the consistency requirement concerning the gradient direction, and is defined as: 
     
       
         
           
             
               
                 
                   ξ 
                   ( 
                   
                     g 
                     , 
                     
                       n 
                       ⁢ 
                       
                         ( 
                         
                           x 
                           , 
                           t 
                         
                         ) 
                       
                     
                     , 
                     
                       
                         ∇ 
                         
                             
                         
                         ⁢ 
                         
                           I 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               + 
                               
                                 r 
                                 · 
                                 
                                   n 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       x 
                                       , 
                                       t 
                                     
                                     ) 
                                   
                                 
                               
                             
                             ) 
                           
                         
                       
                       = 
                       
                         { 
                         
                           
                             
                               
                                 g 
                                 · 
                                 
                                   n 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       x 
                                       , 
                                       t 
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   ∇ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     I 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         x 
                                         + 
                                         
                                           r 
                                           · 
                                           
                                             n 
                                             ⁡ 
                                             
                                               ( 
                                               
                                                 x 
                                                 , 
                                                 t 
                                               
                                               ) 
                                             
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                             
                               
                                 
                                   
                                     for 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     g 
                                   
                                   = 
                                   
                                     
                                       1 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       or 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       g 
                                     
                                     = 
                                     
                                       - 
                                       1 
                                     
                                   
                                 
                                 ⁢ 
                                 
                                     
                                 
                               
                             
                           
                           
                             
                               
                                  
                                 
                                   ∇ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     I 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         x 
                                         + 
                                         
                                           r 
                                           · 
                                           
                                             n 
                                             ⁡ 
                                             
                                               ( 
                                               
                                                 x 
                                                 , 
                                                 t 
                                               
                                               ) 
                                             
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                 
                                  
                               
                             
                             
                               
                                 
                                   for 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   g 
                                 
                                 = 
                                 0 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
     3. Force Calculation 
     Having now defined the gradient flux, we can now define the force f(x,t) used in Eqn. (1). Unlike traditional level set techniques, in which the force f(x,t) is directly calculated at the point x, we first calculate the force on the model boundary, and then expand the force to a narrowband of the boundary. 
     Specifically, for a point x on the boundary ∂(t), we define its neighborhood N r (x,t) as the set of points that are on the boundary ∂(t) and which have distance to x less than a given threshold r. As in deformable surface models (Liu 2005, Shen 2001), a boundary point x of the model is considered as the vertex of its boundary patch N r (x,t), on which the force at point x is calculated. The calculation combines the model constraint(s) with image features. This is done by defining the total force f(x,t) using (i) a gradient flux-based force f a (x,t) obtained using the gradient flux as defined above, which in turn is based on the intensity values, and (ii) an intensity based force f b (x,t) which ensures that model obeys the model constraints. 
     First we obtain the gradient flux-based force. As a first step, the total gradient flux q 0 (x,t) on the boundary patch N r (x,t) is calculated as: 
     
       
         
           
             
               
                 
                   
                     
                       q 
                       0 
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         t 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         
                           x 
                           ′ 
                         
                         ∈ 
                         
                           
                             N 
                             ′ 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               , 
                               t 
                             
                             ) 
                           
                         
                       
                     
                     ⁢ 
                     
                       
                         e 
                         ⁡ 
                         
                           ( 
                           
                             
                               x 
                               ′ 
                             
                             , 
                             
                               n 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     ′ 
                                   
                                   , 
                                   t 
                                 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
     Then, the gradient fluxes q + (x,t) and q − (x,t) are calculated. These correspond respectively to the patch N r (x,t) being shifted to the outside of the model region Ω(r) with unit translation n(x,t), and inside the model region Ω(t) with unit translation −n(x,t)). 
                       q   +     ⁡     (     x   ,   t     )       =       ∑       x   ′     ∈       N   ′     ⁡     (     x   ,   t     )           ⁢     e   ⁡     (         x   ′     +     n   ⁡     (       x   ′     ,   t     )         ,     n   ⁡     (       x   ′     ,   t     )         )                 (   9   )                   q   -     ⁡     (     x   ,   t     )       =       ∑       x   ′     ∈       N   ′     ⁡     (     x   ,   t     )           ⁢     e   ⁡     (         x   ′     -     n   ⁡     (       x   ′     ,   t     )         ,     n   ⁡     (       x   ′     ,   t     )         )                 (   10   )               
where, x′+n(x′,t) and x′−n(x′,t) are points obtained by shifting the point x′ with translation n(x′,t) and −n(x′,t) respectively.
 
     When the q + (x,t) is higher than q − (x,t) and q 0 (x,t), the model boundary ∂(t) is attracted to expand at point x; when q − (x,t) is higher than q + (x,t) and q 0 (x,t), the boundary ∂(t) is urged inward at point x; in other cases, the boundary should remain stationary. Based on these heuristic rules, the gradient flux-based force f a (x,t) is calculated as: 
                       f   a     ⁡     (     x   ,   t     )       =     {               q   +     ⁡     (     x   ,   t     )       ·     n   ⁡     (     x   ,   t     )                     q   +     ⁡     (     x   ,   t     )       &gt;       q   0     ⁡     (     x   ,   t     )         ,         q   +     ⁡     (     x   ,   t     )       &gt;       q   -     ⁡     (     x   ,   t     )                       -       q   -     ⁡     (     x   ,   t     )         ·     n   ⁡     (     x   ,   t     )                     q   -     ⁡     (     x   ,   t     )       &gt;       q   0     ⁡     (     x   ,   t     )         ,         q   -     ⁡     (     x   ,   t     )       &gt;       q   +     ⁡     (     x   ,   t     )                         q   0     ⁡     (     x   ,   t     )       ·     n   ∞           otherwise                   (   11   )               
where, n −  is the unit vector n(x,t) with an additional flag to indicate that the force is used to keep the boundary ∂(r) fixed at point x.
 
     Now we calculate the intensity-based force. Let μ(t) and σ(t) denote the mean and variation of the image intensity within the region, and let and  l (x,t) denote the mean of the image intensity on the boundary patch N r (x,t), i.e.: 
     
       
         
           
             
               
                 
                   
                     μ 
                     ⁡ 
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         x 
                         ∈ 
                         
                           Ω 
                           ⁡ 
                           
                             ( 
                             t 
                             ) 
                           
                         
                       
                     
                     ⁢ 
                     
                       
                         
                           I 
                           ⁡ 
                           
                             ( 
                             x 
                             ) 
                           
                         
                         / 
                         # 
                       
                       ⁢ 
                       
                         ( 
                         
                           Ω 
                           ⁡ 
                           
                             ( 
                             t 
                             ) 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
             
               
                 
                   
                     σ 
                     ⁡ 
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           x 
                           ∈ 
                           
                             Ω 
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                       
                       ⁢ 
                       
                         
                           
                             
                               [ 
                               
                                 
                                   I 
                                   ⁡ 
                                   
                                     ( 
                                     x 
                                     ) 
                                   
                                 
                                 - 
                                 
                                   μ 
                                   ⁡ 
                                   
                                     ( 
                                     t 
                                     ) 
                                   
                                 
                               
                               ] 
                             
                             2 
                           
                           / 
                           # 
                         
                         ⁢ 
                         
                           ( 
                           
                             Ω 
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       I 
                       _ 
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         t 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         
                           x 
                           ′ 
                         
                         ∈ 
                         
                           
                             N 
                             ′ 
                           
                           ⁡ 
                           
                             ( 
                             x 
                             ) 
                           
                         
                       
                     
                     ⁢ 
                     
                       
                         
                           I 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               ′ 
                             
                             ) 
                           
                         
                         / 
                         # 
                       
                       ⁢ 
                       
                         ( 
                         
                           
                             N 
                             ′ 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               , 
                               t 
                             
                             ) 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
     In the case that the gradient characteristic number g of an object is 1, i.e. the intensity inside the object is less than that outside the object, if the intensity  l (x,t) at the boundary point x is greater than μ(t)+σ(t), it is expected that it will be necessary to remove point x from region Ω(t). Thus, we generate an intensity-based force at x which pushes the boundary ∂(t) toward the inside of the region Ω(t). Conversely, otherwise, if  l (x,t)&lt;μ(t)+σ(t), then we generate an intensity-based force to push x outwards. The cases for g=−1 and 0 are similar to g=1. Specifically, motivated by these heuristic rules, the embodiment generates an intensity-based force f b (x,t) at a boundary point x which is calculated as: 
                       f   b     ⁡     (     x   ,   t     )       =     {             n   ⁡     (     x   ,   t     )       ·     φ   ⁡     (     1   -     g   ·       [       I   ⁡     (   x   )       -     μ   ⁡     (   t   )         ]     /     σ   ⁡     (   t   )             )               (       g   =   1     ,     -   1       )                 n   ⁡     (     x   ,   t     )       ·     φ   ⁡     (     1   -              I   ⁡     (   x   )       -     μ   ⁡     (   t   )              /     σ   ⁡     (   t   )           )               (     g   =   0     )                     (   15   )               
where the cut function φ is defined by:
 
φ( u )=min(1,max(−1, u )).  (16)
 
and accordingly limits the force f b (x,t) within the interval [−1, 1].
 
     Let  f   a (t) and f max (t) denote the average and maximum magnitude of forces f a (x,t) on the boundary ∂(t), i.e.: 
     
       
         
           
             
               
                 
                   
                     
                       
                         f 
                         _ 
                       
                       a 
                     
                     ⁡ 
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         x 
                         ∈ 
                         
                           ∂ 
                           
                             ( 
                             t 
                             ) 
                           
                         
                       
                     
                     ⁢ 
                     
                       
                         
                            
                           
                             
                               f 
                               a 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 , 
                                 t 
                               
                               ) 
                             
                           
                            
                         
                         / 
                         # 
                       
                       ⁢ 
                       
                         ( 
                         
                           ∂ 
                           
                             ( 
                             t 
                             ) 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       f 
                       max 
                     
                     ⁡ 
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       max 
                       
                         x 
                         ∈ 
                         
                           ∂ 
                           
                             ( 
                             t 
                             ) 
                           
                         
                       
                     
                     ⁢ 
                     
                        
                       
                         
                           f 
                           a 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             , 
                             t 
                           
                           ) 
                         
                       
                        
                     
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
     The total force f(x,t) is finally estimated from the gradient flux-based force f a (x,t) and the intensity-based force f b (x,t) with the force f a (x,t) as the priority: 
     
       
         
           
             
               
                 
                   
                     f 
                     ⁡ 
                     
                       ( 
                       
                         x 
                         , 
                         t 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             0 
                             _ 
                           
                         
                         
                           
                             
                               
                                 f 
                                 a 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   x 
                                   , 
                                   t 
                                 
                                 ) 
                               
                             
                             = 
                             
                               
                                 
                                   q 
                                   0 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     x 
                                     , 
                                     t 
                                   
                                   ) 
                                 
                               
                               · 
                               
                                 n 
                                 ∞ 
                               
                             
                           
                         
                       
                       
                         
                           
                             
                               
                                 f 
                                 a 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   x 
                                   , 
                                   t 
                                 
                                 ) 
                               
                             
                             / 
                             
                               
                                 f 
                                 max 
                               
                               ⁡ 
                               
                                 ( 
                                 t 
                                 ) 
                               
                             
                           
                         
                         
                           
                             
                               
                                 
                                   f 
                                   a 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     x 
                                     , 
                                     t 
                                   
                                   ) 
                                 
                               
                               ≠ 
                               
                                 
                                   
                                     q 
                                     0 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       x 
                                       , 
                                       t 
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   n 
                                   ∞ 
                                 
                               
                             
                             , 
                             
                               
                                  
                                 
                                   
                                     f 
                                     a 
                                   
                                   ⁢ 
                                   
                                     ( 
                                     
                                       x 
                                       , 
                                       t 
                                     
                                     ) 
                                   
                                 
                                  
                               
                               &gt; 
                               
                                 
                                   
                                     f 
                                     _ 
                                   
                                   a 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                             
                           
                         
                       
                       
                         
                           
                             
                               f 
                               b 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 , 
                                 t 
                               
                               ) 
                             
                           
                         
                         
                           otherwise 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
     We have now fully defined all elements of Eqn. (1) for a point on the boundary. The algorithm implements the level set evolution by a fast narrowband approach (Sethian 1999). We expand the boundary force f(x, t) into a narrowband b r (t) of the boundary ∂(t). 
     In the 3D case, for any voxel x we use N 26 (x) to denote its 26-neighborhood (i.e. its 26 nearest neighbours, which are directly adjacent). At any given time t, we define a set of neighbourhoods {Ω (k) }, for k=0, 1, 2, . . . , with corresponding boundaries {∂ (k) }. Ω (0)  is defined to be equal to Ω(t), and its boundary ∂ (0)  is initially set to ∂(t). For k=0, 1, 2, etc. we define the region Ω (k+1)  and its boundary ∂ (k+1)  iteratively from Ω (k)  and ∂ (k) :
 
∂ (k+1) =[∪ xε∂     (k)     N   26 ( x )]−Ω (k) ,Ω (k+1) =Ω (k) ∪∂ (k+1)   (20)
 
     The force f(x,t) on the set of points ∂ (0)  is first calculated according to Eqn. (19). The embodiment then uses the force on each set of points ∂ (k)  to obtain the force on the set of points ∂ (k+1)  as follows. For any voxel which is ∂ (k+1)  and has position x, the force f(x,t) is a weighted average of the force on those of its 26 nearest-neigbors which are in the set ∂ (k) , i.e.: 
                     f   ⁡     (     x   ,   t     )       =       ∑       x   ′     ∈         N   26     ⁡     (   x   )       ⋂     ∂     (   k   )             ⁢           f   ⁡     (       x   ′     ,   t     )       /     d   ⁡     (     x   ,     x   ′       )         /   #     ⁢     (         N   26     ⁡     (   x   )       ⋂     ∂     (   k   )         )                 (   21   )               
where, d(x,x′) denotes the Euclidean distance of two points x and x′.
 
     The force expansion in the 2D case is similar to that in the 3D case. It differs just by changing the 26-neighborhood in the 3D case into a 8-neighborhood in the 2D case. 
     4. Energy Function 
     The embodiment makes use of an “energy function” to determine when its iterations should terminate. The energy ē(t) of the model is estimated as the negative of the average gradient flux density on the model boundary ∂(t): 
     
       
         
           
             
               
                 
                   
                     
                       e 
                       _ 
                     
                     ⁡ 
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     - 
                     
                       
                         ∑ 
                         
                           x 
                           ∈ 
                           
                             ∂ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                       
                       ⁢ 
                       
                         
                           e 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               , 
                               
                                 n 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     x 
                                     , 
                                     t 
                                   
                                   ) 
                                 
                               
                             
                             ) 
                           
                         
                         ⁢ 
                         # 
                         ⁢ 
                         
                           ( 
                           
                             ∂ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
     5. Implementation Algorithm 
     We are now in a position to define the complete algorithm. This will be explained with reference to  FIG. 3 . The algorithm used by the embodiment is based on the topology preserved narrowband method presented in (Han 2003). Specifically, we propose the following algorithm to update the value φ(x,t i+1 ) from φ(x,t i ):
     1. Initialisation (step  10 ). Set i=0 and the initial value φ(x,t 0 ) to be the signed Euclidean distance map of the initial model (i.e. it is zero for each point on the contour (2D case) or surface (3D case) which is the initial estimate of the object position, and at all other points is the Euclidian distance from the contour/surface multiplied by a sign −1 or +1 according whether the point is inside or outside the region enclosed by the contour or surface). Initialize the sign function s(x, t 0 ), and the narrowband b k (t 0 ), where k is a manually-set parameter to specify the width of the narrowband b k (t) which is defined as the region Ω (k)  obtained according to Eqn 20.   2. Calculate force f(x, t i ) on the boundary ∂(t i ) of the model region Ω(t i ) (step  20 ).   3. Expand the force f(x,t) from boundary ∂(t i ) to its narrowband b k (t i ) (step  30 ).   4. For each point x in b k (t i ), calculate the new value φ(x,t i+1 ) (step  40 )
       a) Detect whether x is a simple point of the point set Ω(t i ) using the method presented in (Bertrand, 1994), where, a simple point means its addition or removal from Ω(t i ) will not change the topology of Ω(t i ).   b) If x is a simple point, update φ(x,t t+1 ) according to Eqn. (3), and then update s(x,t i+1 ) according to Eqn. (4).   c) Otherwise, i.e., x is not a simple point, set φ(x,t i+1 )=ε*sign(φ(x,t i )), where, ε is a small positive number, so that φ(x,t i+1 ) takes a small value while keep the same sign with the old value φ(x,t i ). In this way, the topology of Ω(t i ) is preserved.   
       5. Calculate the total energy e(t i+1 ) (step  50 ).   6. Determine whether e(t i+1 )&gt;e(t i ) (step  60 ), and if so return φ(x,t i ) as the final evolution result (step  70 ); otherwise, go to the next step to begin the next iteration. Alternatively, the termination criterion may be based on the number of iterations reaching a threshold. These two approaches may be combined, so that the algorithm terminates if the number of iterations reaches a threshold without a minimal energy having been reached.   7. Reinitialization: Determine if the zero level set of φ(x,t i+1 ) reaches to the boundary of the current narrowband b k (t i ) (step  80 ). If so, reinitialize φ(x, t i+1 ) to be the signed distance function of its zero level set (step  90 ).   

     6. Results 
     The embodiment was used to segment orbital muscles from MR images.  FIG. 2  shows the segmentation of five muscles with five models in one 2D slice.  FIG. 2(   a ) shows the intensity values of the data set.  FIG. 2(   b ) shows the initial contours.  FIG. 2(   c ) shows the result of the embodiment. It can be seen that the models are deformed to fit the original data quite accurately. 
     REFERENCES 
     
         
         1. Kass, M., Witkin, A., and Terzopoulos, D. (1988) “Snakes: Active contour models,” Int. J. Comp. Vision, vol. 1, pp. 321-331. 
         2. Cohen, L. D. (1991) “On active contour models and balloons,” CVGIP: Image Understanding, 53, pp. 211-218. 
         3. Xu, C. and Prince, J. L. (1998) “Snakes, shapes, and gradient vector flow,” IEEE Trans. Imag. Proc., 7(3), pp. 359-369. 
         4. McInerney, T. and Terzopoulos, D. (1996) “Deformable models in medical image analysis: A survey,” Medical Image Analysis, 1(2), pp. 91-108. 
         5. Cootes T. F., Cooper D., Taylor C. J. and Graham J. (1995) “Active shape models: Their training and Application”, CVIU vol. 61, no. 1, pp. 38-59. 
         6. Cootes T. F., Edwards G. J. and Taylor C. J (2001) “Active appearance models,” IEEE Trans. PAMI vol. 23, no. 6, pp. 681-685 
         7. Shen D., Herskovits E. H. and Davatzikos C (2001) “An Adaptive-Focus Statistical shape model for segmentation and shape modeling of 3-D Brain structure”, IEEE Tran. Med. Imag. vol. 20, no. 4, pp. 257-270 
         8. MacDonald, D., Kabani, N., Avis, D., and Evans, A. C. (2000) “Automated 3-D extraction of inner and outer surfaces of cerebral cortex from MRI,” NeuroImage, 12, pp. 340-356. 
         9. Liu J., Aziz A. (2005) “Deformable associate net approach for chest CT image segmentation”, Proc. SPIE Medical Imaging: Image Processing, Volume 5747 pp. 453-462. 
         10. Malladi, R., Sethian, J. A. and Vemuri, B. C. (1995) “Shape modeling with front propagation: A level set approach,” IEEE Trans. PAMI, 17, pp. 158-175 
         11. Caselles, V., Kimmel, R., and Sapiro, G. (1997) “Geodesic active contours,” Int J. Computer Vision, 22, pp. 61-79. 
         12. Yezzi, A., Kichenassamy, S., Olver, P., and Tannenbaum, A. (1997) “A geometric snake models for segmentation of medical imagery,” IEEE Trans. Med. Imaging, 16, pp. 199-209 
         13. Sethian, J. A. (1999) Level Set Methods and Fast Marching Methods. Cambridge, UK: Cambridge University Press, 2 ed. 
         14. Han X, Xu C, Prince J. L. (2003) “A Topology Preserving Level Set Method for Geometric Deformable Models” IEEE Trans. on PAMI, Vol. 25, No. 6, pp. 755-768 
         15. Bertrand, G. (1994) “Simple points, topological numbers and geodesic neighborhoods in cubic grids,” Pattern Recognition Letters, 15, pp. 1003-1011 
         16. Maurer C. R., Qi J. R. and Raghavan V. (2003) A linear time algorithm for computing exact Euclidean distance transforms of binary images in arbitrary dimensions. IEEE Trans. PAMI, vol. 25 no. 2, pp. 265-270.