Abstract:
A method is proposed for identifying an anatomical structure within a spatial-temporal image (i.e. a series of frames captured as respective times). A current frame of spatial-temporal medical image is processed using information from one or more previous and/or subsequent temporal frames, to aid in the segmentation of an object or a region of interest (ROI) in a current frame. The invention is applicable to both two- and three-dimensional spatial-temporal images (i.e., 2D+time or 3D+time), and in particular to cardiac magnetic resonance (CMR images). An initialisation process for this method segments the left ventricle (LV) in a CMR image by a fuzzy c-means (FCM) clustering algorithm which employs a circular shape function as part of the definition of the dissimilarity measure.

Description:
FIELD OF THE INVENTION 
       [0001]    The present invention relates to methods and apparatus for identifying anatomical structures within medical images, especially spatial-temporal medical images (that is, a series of two- or three-dimensional images (“frames”) captured at successive respective times). The invention relates particularly to identification of anatomical structures within cardiac magnetic resonance (CMR) images of the heart of a subject. Nevertheless, the invention is sufficiently generic to be applicable for identification of dynamic anatomical or biological structures from other imaging modalities that produce time-series images, such as computed tomography and ultrasound images of the heart and the lungs, and cell transport images from digital microscopy. 
       BACKGROUND OF THE INVENTION 
       [0002]    Spatial-temporal medical images such as those obtained from Cardiac Magnetic Resonance (CMR) images provide important information for diagnosis and treatment of cardiovascular diseases in a non-invasive manner. The CMR technique is considered the current gold standard for imaging the structure and function of the heart. To help in the diagnosis of disease, physicians are interested in identifying the heart chambers and measuring the change in ventricular blood volume (i.e., ejection fraction=stroke volume/end-diastolic volume×100%) and wall thickening over the cardiac cycle. Accurate extraction of the anatomical boundaries of the heart chambers is crucial to obtain reproducible quantitative measurements to support the diagnosis and follow-up of cardiac pathologies. However, manual delineation of the anatomical structures is time-consuming and tedious (even a trained clinician takes 20 minutes to do this), and limited by inter- and intra-observer variability. Therefore, it is highly desirable to develop techniques for automatic CMR image segmentation (that is, the identification of contours within images which, correspond to the outlines of specified anatomical structures). 
         [0003]    Automatic segmentation of the human left ventricle (LV) and right ventricle (RV) from CMR data, in particular LV segmentation and tracking, has been addressed in the last two decades. Known ventricle segmentation techniques can be broadly classified into four major approaches: image-based methods, deformable model-based methods, registration-based-methods, and graph-based methods. The first approach utilizes basic image analysis operators such as thresholding, region-growing, image morphology, edge detection, pixel classification, etc, to delineate the LV and RV boundaries from the image. It uses information obtained directly from the image itself and requires no or minimal prior information from the user (i.e. the human operator of the computer). The second approach trains a shape/curve model of the LV or RV using images of previous subjects, and lets the curve model evolve in images of new subjects until it converges to the LV or RV boundaries. It takes advantage of the fact that ventricles of different subjects have similar shapes. The basic idea of the third approach is to transfer expert segmentations of training images (i.e., atlases) onto target images through image registration, and then fuse the transferred segmentations to derive an ultimate segmentation. The last approach also does not require heavy reliance on explicitly learned or encoded priors, but the user has to initialize a set of foreground and background seeds. 
         [0004]    Although ventricle segmentation methods have improved over the last few decades, accurate LV and RV segmentation is still acknowledged as a difficult problem, especially for RV segmentation (due to the high anatomical complexity and poorly-delineated ventricular boundaries of the RV). Clinical applicability of most of the developed techniques for segmenting cardiac structures robustly is yet to be realised. Automatic segmentation of LV and RV from CMR data typically faces four challenges: 1) the lack of edge information; 2) the overlap between the intensity distributions within the cardiac regions; 3) the shape variability of the ventricle contours across slices and phases; and 4) the inter-subject variability of these factors. 
         [0005]    Conventionally, the most common technique to handle these challenges is to incorporate prior model information into the segmentation, such as the active shape model, active appearance model, and anatomical atlas registration model, etc. However, such models need to be constructed or learned from many manually segmented images, which is cumbersome, labour-intensive, subjective and of limited use due to anatomical variability (pathology typically causes large variability in anatomical structures) and image contrast variability (e.g., due to artefacts or different imaging protocols). In addition, most existing ventricle segmentation methods operate on static images. As a result, the segmentation performance is limited by the data available in an individual frame, particularly for low signal-to-noise ratio (SNR) images, where the observation from a single frame alone may not provide enough information for a good segmentation. 
         [0006]    Furthermore, to achieve full automation and eliminate inter- and intra-observer variability, the initialization of an image segmentation algorithm should also be automatic, and there is currently still a need for a fast and robust initialization procedure. Many automatic medical image segmentation techniques rely on a combination of information directly derived from the image and information provided by prior models of anatomy and its appearance in the image. Due to the limitations and the construction cost of prior models, methods that rely primarily on image information have distinct advantages. 
       SUMMARY OF THE INVENTION 
       [0007]    The present invention aims to provide new and useful methods for identifying anatomical structures within spatial-temporal medical images, and particularly for identifying anatomical structures within cardiac magnetic resonance (CMR) images of the heart of a subject. 
         [0008]    In general terms, a first aspect of the invention proposes that a current frame of spatial-temporal medical image is processed using information from one or more previous and/or subsequent temporal frames, to aid in the segmentation of an object or a region of interest (ROI) in a current frame. The invention is applicable to both two- and three-dimensional spatial-temporal images (i.e., 2D+time or 3D+time). 
         [0009]    In other words, the invention proposes that the current frame is processed using information from to one or more neighbouring frames. The term “neighbour” is used in this document to include nearest neighbour (i.e. the immediately preceding or succeeding frame), but the term is used to include also all the preceding and/or succeeding frames within a predefined neighbourhood of the current frame (i.e. within a certain number of frames k from the current frame). 
         [0010]    The invention makes possible an intelligent image segmentation process which incorporates an automatic contour initialization mechanism, and a segmentation refinement mechanism that iteratively improves the segmentation results. 
         [0011]    Over the duration of a single cardiac cycle, the standard cine-MRI protocol acquires approximately 20-25 frames of stacked images of the heart. Since adjacent frames are imaged over a short time period (approximately 50 ms), the LV and RV boundaries exhibit strong temporal correlation. Thus, ventricle boundaries identified in the adjacent frames may provide information regarding the location of the ventricular boundary in the current frame. The present invention exploits the dynamics of the heart and incorporates the information from adjacent frames into the detection and tracking of the evolving ventricle boundaries. 
         [0012]    The present invention makes possible, in particular, a computer-aided methodology to segment the LV and RV with minimal user interaction in 2D+T spatio-temporal images produced by short-axis CMR. An intialisation propagation mechanism allows the result of segmenting one frame to be used for the contour initialisation of successive frames (or, more generally, contour initialisation of one or more previous and/or subsequent frame(s)) until the segmentation is done on all the frames. An segmentation refinement mechanism allows the segmented contours of the previous and/or subsequent frames to be used to refine the result of the current frame. 
         [0013]    The presented framework is general and most of the image segmentation algorithms mentioned in the background section of this document can be integrated into it. The incorporation of the memory persistent methodology into the CMR image segmentation makes possible a better segmentation performance in terms of accuracy and robustness when compared to the original method. It may provide greater insensitivity to contour initialization. 
         [0014]    The invention is inspired by how human make use of the persistence of memory, i.e. using memory to assist current action. In neurological research, persistence of memory refers to the way that memories are stored so that they are accessible and can be used in the future. Cardiologists apply similar cognitive processing (the segmentation result of the current frame will be affected by the memory of the results from the past and/or previous frames) to aid in the decision making during manual segmentation of cardiac images, especially when boundaries of the ROI are vague. Even when there is a lack of edge information of the LV or RV ROI in a current frame, the cardiologist can still identify a reasonable contour by remembering what he observed in the past/previous frames. Inspired by such memory persistence, the present invention provides a segmentation framework to incorporate the dynamic information from previous and/or future frames into the detection and tracking of the evolving LV and RV boundaries. 
         [0015]    A second aspect of the invention proposes a cardiac magnetic resonance (CMR) image segmentation method based on fuzzy image segmentation that is predominantly image-driven. It does not use any prior knowledge, and makes only plausible assumptions about the image and the imaged heart. 
         [0016]    In general terms, the second aspect of the invention proposes segmenting a CMR image, such as segmentation of the left ventricle (LV) endocardial border, by a fuzzy c-means (FCM) clustering algorithm which employs a circular shape function as part of the definition of the dissimilarity measure. 
         [0017]    Embodiments of the proposed circular shape constrained FCM (CS-FCM) algorithm can integrate both intensity related feature and spatial shape information into the clustering procedure. As a result, pixels having similar intensity information but located in different regions (LV region or non-LV region) can be differentiated. 
         [0018]    A weighting parameter may be used to adjust the weight of the spatial distance against the intensity feature, which increases the flexibility of the proposed CS-FCM algorithm. 
         [0019]    Experimental results of using embodiments of the second aspect of the invention to process real CMR images have demonstrated two obvious advantages of the proposed CS-FCM over standard clustering algorithms like FCM: the CS-FCM method successfully distinguishes the LV from other structures which have similar intensity to the LV; and it correctly segments the LV even when papillary muscles are adjacent to or fall inside the LV region. 
         [0020]    The CS-FCM method may be used to produce an initial segmentation of an image of the LV, which is a first frame of a spatial-temporal image of the LV, and the result is used as the initialization of a method according to the first aspect of the invention, to segment other frames of the spatial-temporal image. That is, the second aspect of the invention may be used for initialization of a method according to the first aspect of the invention. 
         [0021]    The methods of the present invention are preferably performed automatically by a computer processor of a computer system (e.g. a general purpose computer such as a personal computer (PC)), running computer program instructions. The term “automatically” is used to mean substantially, without human involvement, except as regards to initialization of the method. The initialization may include indicating a region of interest (ROI) on the image, to which the methods of the invention may be applied. 
         [0022]    The results of the methods of the present invention may be used in a method of identifying an irregularity in the anatomical structure. Once the irregularity is identified, a process such as a surgical process may be used to address the irregularity. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0023]    Embodiments of the invention will now be described for the sake of example only with reference to the following figures, in which: 
           [0024]      FIG. 1  is a flow-chart of the intra-image processing framework of the memory persistence method; 
           [0025]      FIG. 2  is a flow-chart of the inter-image processing framework of the memory persistence method; 
           [0026]      FIG. 3  shows four sequential CMR images used for the testing the embodiment; 
           [0027]      FIG. 4  shows how the four CMR images (in the top row of  FIG. 4 ) are processed by the prior art GVF method (the second row of  FIG. 4 ) and the embodiment of  FIG. 2 ; 
           [0028]      FIG. 5  compares how two synthetic images (shown in the left column) are segmented by conventional FCM (middle column) and an embodiment of the CS-FCM aspect of the invention (right column); 
           [0029]      FIG. 6  compares how five frames of a real CMR sequence (shown in the top row) are segmented by conventional FCM (middle row) and an embodiment of the CS-FCM aspect of the invention (bottom row); and 
           [0030]      FIG. 7  compares how five further frames of a real CMR sequence (shown in the top row) are segmented by conventional FCM (middle row) and an embodiment of the CS-FCM aspect of the invention (bottom row). 
       
    
    
     DETAILED DESCRIPTION OF THE EMBODIMENTS 
     1. Embodiment of the “Memory Persistence” Aspect of the Invention 
       [0031]    The following explanation denotes a sequence of two-dimensional (2D) CMR image frames from a single cardiac cycle as: 
         [0000]        I   t ( x,y )  t= 1,2, . . . , N    
         [0000]    where I t (x,y) denotes the 2D image frame at time t, and N is the total number of frames in a single cardiac cycle. 
         [0032]    From these images it is intended to generate a contour, and to produce corresponding segmented binary images in which the intensity of the pixels within the contour is set to 255, and the intensity of other pixels is set to 0. The segmented binary images are denoted by 
         [0000]        B   t ( x,y )  t= 1,2, . . . , N    
         [0000]    where B t (x,y) denotes the 2D binary image from the segmentation of the image frame I t (x,y) at time t. 
         [0033]    To segment a given frame at time t, instead of solely using the information from the current image I t (x,y) (as did most of the existing methods), the proposed framework incorporates into the segmentation techniques information from segmented binary images of previous and/or future frames, specifically from time t−k to time t+k. The number of previous and future frames is thus determined by the integer parameter k, which will be discussed later in this section. 
         [0034]    The framework is general and most existing image segmentation methods can be integrated into it. However, for the convenience of illustration, the present embodiment uses the active contour model—gradient vector flow (GVF) model—to exemplify the utility of a framework according to the invention. Detailed information about GVF can be found in Chenyang Xu, Jerry L. Prince. Snakes, Shapes, and Gradient Vector Flow. IEEE Transactions on Image Processing 7(3): 359-369, March 1998. 
         [0035]    An active contour or snake is a curve defined within an image domain that can deform under the influence of internal forces coming from within the curve itself and external forces arising from the image data. The internal and external forces are defined so that the snake will conform to an object boundary or other desired features within an image. The GVF forces are dense vector fields derived from images by minimising the energy functional 
         [0000]        E =∫∫μ( u   x   2   +u   y   2   +v   x   2   +v   y   2 )+|∇ƒ| 2   |V−∇ƒ|   2   dxdy   (A)
 
         [0000]    where V(I(x,y))=[u(x,y),v(x,y)] denotes the GVF force of the image I(x,y), ƒ(x,y) is an edge map of the image I(x,y), ∇ƒ is the gradient of the edge map ƒ(x,y), and μ is a weighting parameter. For a binary image, suitable edge map functions are ƒ (1) (x,y)=−I(x,y) and ƒ (2) (x,y)=G σ (x,y)*I(x,y), where G σ (x,y) is a two-dimensional Gaussian function with standard deviation σ. For general grayscale images, suitable edge map functions are ƒ (3) (x,y)=−|∇I(x,y)| 2  and ƒ (4) (x,y)=−|∇[G σ (x,y)*I(x,y)]| 2  where ∇ is the gradient operator. The value of V is then obtained by solving the following two Euler equations: 
         [0000]      μ∇ 2   u −( u−ƒ   x )(ƒ x   2 +ƒ y   2 )=0
 
         [0000]      and 
         [0000]      μ∇ 2   v −( v−ƒ   x )(ƒ x   2 +ƒ y   2 )=0
 
         [0000]    where ∇ 2  is the Laplacian operator, ƒ x  denotes ∂ƒ/∂x, and ƒ y  denotes ∂ƒ/∂y. 
         [0036]    Compared to the previous active model or snake techniques, the GVF has been proven superior to many force field methods due to its greater active range, especially in its ability to approach the boundary of concave regions. 
         [0037]    For each image I t (x,y) at time t, the embodiment calculates its GVF force V(I t (x,y)) by minimizing the energy functional (Equation A), and stores it in memory. The minimization algorithm begins with an initial estimate of the position of the desired contour (GVF snake), which in effect specifies a region of interest (ROI)—i.e. it specifies the anatomical structure which the embodiment segments. In the case that the present method is used to find the contour of the LV, that initial estimate may be found using the CS-FSM model (see below), which has been found to give an estimate of the LV which is sufficiently close to the actual region of interest for the LV (i.e. the endocardial boundary of the left ventricle chamber) to ensure that the embodiment produces a good segmentation result. For other anatomical structures, other initial estimates may be better. A manual positioning of the contour would work for any structure (such as the RV, or indeed the lungs if the application is used for a different portion of the body). Note that this manual positioning only has to be done for one frame of the spatial-temporal image, since, as explained below the segmentation of that frame is used to provide initialization for the other frames. 
         [0038]    The embodiment uses the converged result for V(I t (x,y)) to produce a binary image B t (x,y), where the binary values respectively represent that pixel (x,y) is believed to the inside or outside the anatomical structure. 
         [0039]    Similarly, the embodiment calculates the GVF force for each segmented binary image B t (x,y) at time t, denoted by V(B t (x,y)), and stores it in memory. V(B t (x,y)) is obtained based on the first two edge map functions mentioned earlier, i.e., ƒ (1)  and ƒ (2) , since this is a binary image. 
         [0040]    To incorporate the dynamic information from the previous and future frames into the segmentation of the current frame, the invention uses a combination of GVF forces from both the original image I(x,y) and k preceding and k succeeding binary images B(x,y) in the sequence to define a modified GVF force V* denoted by: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       V 
                       * 
                     
                      
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       V 
                        
                       
                         ( 
                         
                           
                             I 
                             t 
                           
                            
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         ) 
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           
                             t 
                             - 
                             k 
                           
                         
                         
                           t 
                           + 
                           k 
                         
                       
                        
                       
                         
                            
                           
                             
                               - 
                               σ 
                             
                              
                             
                                
                               
                                 i 
                                 - 
                                 t 
                               
                                
                             
                           
                         
                          
                         
                           V 
                            
                           
                             ( 
                             
                               
                                 B 
                                 i 
                               
                                
                               
                                 ( 
                                 
                                   x 
                                   , 
                                   y 
                                 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   B 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where k is the integer parameter denotes the time offset, i.e., the number of frames from the previous and future frames, V(I t (x,y)) and V(B t (x,y)), respectively, are the GVF forces of original image I t (x,y) and binary image B t (x,y), respectively, and σ is a weighting parameter that controls the weight of the GVF force from the binary images. Note that the summation preferably includes i=t. As seen from Equation (B), the stored GVF forces from the previous and future frames are combined into the current frame, which is in accordance with the claim that dynamic information is used for dynamic evolution of the ventricle shape. 
         [0041]    The memory persistence approach for segmenting a region-of-interest (ROI) from a cyclic sequence of images I t (x,y) consists of two main components: The first component relates to intra-image processing while the second component relates to inter-image processing. The aim of the former is to perform image segmentation to obtain a “memory imprint” while the latter utilises the “memory imprints” across multiple images for refinement of the segmentation results. 
         [0042]    The intra-image processing component for a particular i-th iteration consists of the following steps:
       (1) Input an initial configuration of the contour in the image I t (x,y) at time t. This initial contour can be defined as follows:
           a. If this is the first iteration and I t (x,y) is the starting image of the whole memory persistence process, the initial contour is defined manually or by a suitable contour initialisation procedure, such as the CS-FCM algorithm (see below).   b. If this is the first iteration and I t (x,y) is not the starting image of the whole memory persistence process, the initial contour is defined automatically by propagating the image segmentation result of an adjacent frame to itself, and using that as the initial contour.   c. If this is not the first iteration, the image segmentation result of the previous iteration is used as the initial contour.   
           (2) Calculate the GVF force V(I t (x,y)) using Equation (A) with ƒ (3)  or ƒ (4)  as the edge map function. Store the result.   (3) Use the GVF model to evolve the initial contour in Step (1) to obtain the segmentation the ROI.   (4) Obtain the binary image B t (x,y) corresponding to the segmented contour of the ROI.       (5) Calculate the GVF force V(B t (x,y)) using Equation (A) with ƒ (1)  or ƒ (2)  as the edge map function. Store the result. V(B t (x,y)) is the memory imprint that will influence the GVF forces of its neighbouring frames.   
 
         [0051]    A schematic of the intra-image processing procedure is shown in  FIG. 1 . 
         [0052]    The inter-image processing component is an iterative process and a synchronous update approach will be described. In practice, it is also possible to adopt an asynchronous update approach. The procedure consists of the following steps:
       (1) Define the persistence duration k, in terms of the number of frames. For example, if k=2, the segmentation result of a particular frame will be influenced by the memory imprints of the 2 frames preceding it and the 2 frames succeeding it.   (2) For the first iteration, perform the intra-image processing steps described above for every frame in the image sequence. As mentioned, for the starting image, an initial contour needs to be provided, either manually or by a suitable algorithm. The segmented contour of this starting frame can then be propagated to the adjacent frame.   (3) For every frame in the sequence, calculate the updated GVF force V* (x,y) using Equation (B). Store the results of V* (x,y) for all frames.   (4) Use the updated GVF model in each frame to evolve its existing contour to obtain a refined segmentation of the ROI.   (5) Obtain the binary image B t (x,y) corresponding to the refined segmented contour of the ROI for each frame.   (6) Calculate the GVF force V(B t (x,y)) using Equation (A) with ƒ (1)  or ƒ (2)  as the edge map function. Store the result.   (7) Repeat Steps (3) to (6). The number of iterations is determined by the user. Using an unduly large number of iterations can result in over-smoothing. In practice, 5 to 10 iterations are sufficient. Alternatively, the implementation can be incorporated into a semi-supervised process to allow user to decide when to terminate the iteration.       
 
         [0060]    A schematic of the inter-image processing procedure is shown in  FIG. 2 . 
       Results 
       [0061]    To demonstrate and evaluate the performance of the embodiment, we apply it to segment RV on a sequence of CMR image frames. RV segmentation is acknowledged as a very challenging problem due to its anatomical complexity. For the purpose of qualitative comparison, all the images are also subjected to the original GVF model. 
         [0062]      FIG. 3  shows four sequential CMR images. From the bottom-left corner of Frame  120 , it can be observed that the RV boundary is very fuzzy, and that there is a sharp edge located in the left side of the vicinity. It will be difficult for most existing segmentation methods to delineate the RV boundary in this frame. Segmentation may fail due to the lack of boundary information or image field distortion by the sharp edge. The boundary becomes clearer and clearer through Frames  121  to  123 . 
         [0063]    We applied the original GVF method and the embodiment to the four sequential images of  FIG. 3 .  FIG. 4  shows the segmentation results. The first row (top row) of  FIG. 4  is the original images with fine contour initialisations, the initial contours are indicated by a line. All the contours in the top row are defined manually, so that they lie close to the actual boundaries of the ROI. The second row and third row show the segmentation results by the original GVF method and the presented framework, respectively. In each case, the segmented contours are indicated by a line. From the second row, it can be observed that even with a fine initialisation, the GVF method still wrongly deforms the RV contour to the sharp edge in Frame  120 . Also, in Frames  121  and  122 , the RV contour deformation is distorted by the sharp edge to some extent; the only good result is achieved in Frame  123 . In contrast, the embodiment (as shown in the third row) achieves good results for all four frames. The incorporation of the dynamic information passed from the past frames to the current frame can prevent the distortion due to the sharp edge. 
         [0064]    Furthermore, the embodiment requires the initialisation for one frame only (frame  123 ); for each other frame, the segmented contour from the previous frame will be propagated to the current frame as the initialisation. In comparison, the original GVF method requires contour initialisation for every individual frame in the sequence, which is a hindrance to automation. 
         [0065]    As noted above, the GVF method is just one of the possible applications of the first aspect of the invention. To adapt the embodiment to other methods, we would change Equations (A) and (B) to a form appropriate to the alternative image segmentation kernel. 
       2. Embodiment of the Contour Initialisation Aspect of the Invention 
       [0066]    The following paragraphs describe an embodiment of the clustering aspect of the invention, referred to as the circular shape fuzzy c-means (CS-FCM) image segmentation algorithm. A brief review of the fuzzy c-means (FCM) algorithm is presented first, followed by a description of the embodiment. 
         [0067]    Mathematically, the FCM algorithm is used to minimize an objective function J fcm , with respect to the membership function u k|ij  and the cluster centre v k , such that 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       J 
                       fcm 
                     
                     = 
                     
                       
                         ∑ 
                         
                           
                             x 
                             ij 
                           
                           ∈ 
                           I 
                         
                       
                        
                       
                         
                           ∑ 
                           
                             k 
                             = 
                             1 
                           
                           K 
                         
                          
                         
                           
                             
                               
                                 ( 
                                 
                                   u 
                                   
                                     k 
                                     | 
                                     ij 
                                   
                                 
                                 ) 
                               
                               m 
                             
                             · 
                             
                               d 
                               kij 
                             
                           
                            
                           
                               
                           
                            
                           subjected 
                            
                           
                               
                           
                            
                           to 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       
                         
                           ∑ 
                           
                             k 
                             = 
                             1 
                           
                           K 
                         
                          
                         
                           u 
                           
                             k 
                             | 
                             ij 
                           
                         
                       
                       = 
                       1 
                     
                     , 
                     
                       
                         u 
                         
                           k 
                           | 
                           ij 
                         
                       
                       ∈ 
                       
                         [ 
                         
                           0 
                           , 
                           1 
                         
                         ] 
                       
                     
                     , 
                     
                       ∀ 
                       
                         
                           x 
                           ij 
                         
                         ∈ 
                         I 
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where m is a weighting exponent on the fuzzy memberships. Note that x i,j  simply refers to the pixel (i,j) of the image I, and the first summation above is over all pixels in the image. 
         [0068]    A value of m=2 is known to give good results with the FCM algorithm. The parameter u k|ij  is the membership of the (i,j)th pixel x ij  in the (k)th cluster, and d kij  is the squared Euclidean distance between the pixel x ij  and the cluster centre v k  where 
         [0000]        d   kij   =∥x   ij   −v   k ∥ 2   (2)
 
         [0069]    The minimization of (1) gives the updating equations for the membership u k|ij  and cluster centre v k , which are given by 
         [0000]    
       
         
           
             
               
                 
                   
                     u 
                     
                       k 
                       | 
                       ij 
                     
                   
                   = 
                   
                     
                       
                         
                           
                             ( 
                             
                               
                                 x 
                                 ij 
                               
                               - 
                               
                                 v 
                                 k 
                               
                             
                             ) 
                           
                           
                             
                               - 
                               2 
                             
                             / 
                             
                               ( 
                               
                                 m 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                         
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             K 
                           
                            
                           
                             
                               ( 
                               
                                 
                                   x 
                                   ij 
                                 
                                 - 
                                 
                                   v 
                                   k 
                                 
                               
                               ) 
                             
                             
                               
                                 - 
                                 2 
                               
                               / 
                               
                                 ( 
                                 
                                   m 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                           
                         
                       
                        
                       
                           
                       
                        
                       and 
                        
                       
                           
                       
                        
                       
                         v 
                         k 
                       
                     
                     = 
                     
                       
                         
                           ∑ 
                           
                             
                               x 
                               ij 
                             
                             ∈ 
                             I 
                           
                         
                          
                         
                           
                             u 
                             
                               k 
                               | 
                               ij 
                             
                             m 
                           
                            
                           
                             x 
                             ij 
                           
                         
                       
                       
                         
                           ∑ 
                           
                             
                               x 
                               ij 
                             
                             ∈ 
                             I 
                           
                         
                          
                         
                           u 
                           
                             k 
                             | 
                             ij 
                           
                           m 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0070]    The FCM algorithm is summarized as follows:
   1) Fix the cluster number K.   2) Initialize the cluster centres {v k } k=1   K .   3) Update the membership function and cluster centre by using Equation (3) until ∥v new −v old ∥≦ε, where ε is a small positive threshold, e.g., ε=0.001.   
 
         [0074]    Turning to the embodiment, let ƒ k (i,j,s) represent the geometric circular shape function. By incorporating it into (2), we have anew dissimilarity measure {circumflex over (d)} kij , as shown below 
         [0000]        {circumflex over (d)}   kij   =d   kij +αƒ k ( i,j,s )  (4)
 
         [0000]    where α is the weighting parameter used to adjust the weight of the spatial shape information against the intensity related feature. The function ƒ can be seen as a penalty term which is applied equally to all the clusters. The effect is to make the FCM clustering algorithm separate the pixels into groups/clusters that are of similar intensity and form the shape of a circle. The circular shape function ƒ k (i,j,s) is expressed as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         f 
                         k 
                       
                        
                       
                         ( 
                         
                           i 
                           , 
                           j 
                           , 
                           s 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         
                           [ 
                           
                             
                               
                                 
                                   ( 
                                   
                                     i 
                                     - 
                                     
                                       x 
                                       c 
                                     
                                   
                                   ) 
                                 
                                 2 
                               
                               + 
                               
                                 
                                   ( 
                                   
                                     j 
                                     - 
                                     
                                       y 
                                       c 
                                     
                                   
                                   ) 
                                 
                                 2 
                               
                             
                             r 
                           
                           ] 
                         
                         
                           β 
                           k 
                         
                       
                        
                       
                           
                       
                        
                       where 
                     
                   
                    
                   
                       
                   
                    
                   
                      
                   
                    
                   
                     s 
                     = 
                     
                       { 
                       
                         
                           x 
                           c 
                         
                         , 
                         
                           y 
                           c 
                         
                         , 
                         r 
                       
                       } 
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0000]    is a unique clique (i.e. set of values) that denotes the circular shape, x c  and y c  denote the geometric x- and y-coordinates of the centre of a circular shape, and r denotes the radius of the circular shape. The exponent parameter β k  ensures a small value for the pixels within the k-th cluster and a large value for the pixels outside the cluster. 
         [0075]    The circular shape function ƒ k (i,j,s) represents geometric information and its influence in the objective function is controlled by the weighting parameter α. The dissimilarity measure {circumflex over (d)} kij  consists of a measure of the intensity dissimilarity between the (i,j)th pixel x ij  and the (k)th centre v k  in the intensity space as well as a distance dissimilarity in the spatial space. With the inclusion of the circular shape information, several advantages are achieved:
   i) Pixels with similar intensity but located in disjointed regions can be differentiated; and   ii) A large membership for the cluster associated with the LV region can be obtained.   
 
         [0078]    By using the newly defined dissimilarity measure in Equation (4), the embodiment performs the minimization of the following objective function 
         [0000]    
       
         
           
             
               
                 
                   
                     J 
                     
                       cs 
                        
                       
                         - 
                       
                        
                       fcm 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         
                           x 
                           ij 
                         
                         ∈ 
                         I 
                       
                     
                      
                     
                       
                         ∑ 
                         
                           k 
                           = 
                           1 
                         
                         K 
                       
                        
                       
                         
                           
                             ( 
                             
                               u 
                               
                                 k 
                                 | 
                                 ij 
                               
                             
                             ) 
                           
                           m 
                         
                         · 
                         
                           
                             d 
                             ^ 
                           
                           kij 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0079]    The partial derivative of J cs-fcm  with respect to membership u k|ij  and cluster centre v k  yields the following updating equations 
         [0000]    
       
         
           
             
               
                 
                   
                     u 
                     
                       k 
                       | 
                       ij 
                     
                   
                   = 
                   
                     
                       
                         
                           
                             d 
                             ^ 
                           
                           kij 
                           
                             
                               - 
                               1 
                             
                             / 
                             
                               ( 
                               
                                 m 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                         
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             K 
                           
                            
                           
                             
                               d 
                               ^ 
                             
                             kij 
                             
                               
                                 - 
                                 1 
                               
                               / 
                               
                                 ( 
                                 
                                   m 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                           
                         
                       
                        
                       
                           
                       
                        
                       and 
                        
                       
                           
                       
                        
                       
                         v 
                         k 
                       
                     
                     = 
                     
                       
                         
                           ∑ 
                           
                             
                               x 
                               ij 
                             
                             ∈ 
                             I 
                           
                         
                          
                         
                           
                             u 
                             
                               k 
                               | 
                               ij 
                             
                             m 
                           
                            
                           
                             x 
                             ij 
                           
                         
                       
                       
                         
                           ∑ 
                           
                             
                               x 
                               ij 
                             
                             ∈ 
                             I 
                           
                         
                          
                         
                           u 
                           
                             k 
                             | 
                             ij 
                           
                           m 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0080]    The partial derivative of J cs-fcm  with respect to s gives 
         [0000]    
       
         
           
             
               
                 
                   
                     x 
                     c 
                   
                   = 
                   
                     
                       
                         
                           
                             ∑ 
                             
                               
                                 x 
                                 ij 
                               
                               ∈ 
                               I 
                             
                           
                            
                           
                             i 
                             · 
                             
                               u 
                               
                                 k 
                                 | 
                                 ij 
                               
                               m 
                             
                           
                         
                         
                           
                             ∑ 
                             
                               
                                 x 
                                 ij 
                               
                               ∈ 
                               I 
                             
                           
                            
                           
                             u 
                             
                               k 
                               | 
                               ij 
                             
                             m 
                           
                         
                       
                        
                       
                           
                       
                        
                       and 
                        
                       
                           
                       
                        
                       
                         y 
                         c 
                       
                     
                     = 
                     
                       
                         
                           
                             ∑ 
                             
                               
                                 x 
                                 ij 
                               
                               ∈ 
                               I 
                             
                           
                            
                           
                             j 
                             · 
                             
                               u 
                               
                                 k 
                                 | 
                                 ij 
                               
                               m 
                             
                           
                         
                         
                           
                             ∑ 
                             
                               
                                 x 
                                 ij 
                               
                               ∈ 
                               I 
                             
                           
                            
                           
                             u 
                             
                               k 
                               | 
                               ij 
                             
                             m 
                           
                         
                       
                        
                       
                           
                       
                        
                       and 
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
             
               
                 
                   r 
                   = 
                   
                     
                       
                         ∑ 
                         
                           
                             x 
                             ij 
                           
                           ∈ 
                           LV 
                         
                       
                        
                       
                         
                           ( 
                           
                             i 
                             - 
                             
                               x 
                               c 
                             
                           
                           ) 
                         
                         2 
                       
                     
                     + 
                     
                       
                         ( 
                         
                           j 
                           - 
                           
                             y 
                             c 
                           
                         
                         ) 
                       
                       2 
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0081]    The CS-FCM algorithm is summarized in the following steps:
   Step 1: Fix the cluster number K. Initialize the cluster centres {v k } k=1   K .   Step 2: Update the membership function and cluster centre by using Equation (7).   Step 3: Update the circular shape by using Equations (8) and (9).   Step 4: Repeat Steps 2 to 3 until ∥v new −v old ∥≦ε, where ε is a small positive threshold, e.g., ε=0.001.   
 
       Results 
       [0086]    To demonstrate the performance of the proposed CS-FCM method for cardiac LV segmentation we performed the following experiments on real CMR images. For the purpose of qualitative comparison, all the images were also subjected to the standard FCM algorithm. In all examples, we fixed the cluster number as K=2 (i.e. one cluster for LV region and the other for non-LV region) and the weighting parameter as α=0.3 for the CS-FCM. The experimental were produced using β k =2 for the LV region, and β k =−2 for the non-LV region. 
         [0087]    Before performing the segmentation on the real CMR images, we demonstrate the effectiveness of the proposed CS-FCM on two synthetic images, which are the two images in the left column of  FIG. 5 . It is desired that the method would the target separate the big bright ball in each synthetic image from the others. 
         [0088]    The segmentation results of FCM are shown in the second column. The pixels are clustered into two clusters which are respectively shown by a high or low intensity. It can be seen that the FCM partitions the images such that pixels having a similar intensity are treated as belonging to the same cluster even though they are a long way apart. In other words, because it uses the intensity of the original image only, the FCM will cluster all the objects with similar intensity into one cluster regardless of their locations. By contrast, the proposed CS-FCM integrates the spatial shape information into the clustering procedure, such that objects with similar intensity but located in different regions can be differentiated. As shown in the third column, the proposed CS-FCM successfully partitions the image such that the pixels in the bright ball are identified as being one cluster. 
         [0089]      FIG. 6  and  FIG. 7  show the segmentation results of the standard FCM and the proposed CS-FCM on CMR images. The images in the top row of  FIGS. 6 and 7  are the original CMR images. The segmentation results based on the standard FCM are shown in the middle row in  FIG. 6  and  FIG. 7 . It can be observed from the figures that the standard FCM failed to separate the LV region from the image: the LV region is partitioned into one cluster together with other objects having bright intensities. By contrast, as shown in the bottom row of images, the proposed CS-FCM achieves much better results: it successfully distinguishes the LV from other structures which have similar intensity as the LV; and it correctly segments the LV even when papillary muscles are adjacent to or fall inside the LV region. This illustrates the basic idea of this approach that is to incorporate the circular shape function into the standard FCM algorithm, such that pixels having similar intensity but located in different regions can be differentiated.