the general context of the present work is the cervical vertebra mobility analysis on x - ray images .
the issue is to determine the angles between adjacent vertebr on radiographs characterized by 3 patient 's positions : flexion , neutral , and extension . in , puglisi et al .
describe a protocol for the analysis of cervical vertebra mobility applied to hospital diagnosis or to scientific research .
they show that for the mobility analysis , the vertebra contour needs to be defined by a human operator .
one way to extract quantitative data is to segment the vertebr by digital image processing . nowadays ,
regular radiography of the spine is the cheapest and the fastest way for a physician to detect vertebral abnormalities .
furthermore , as far as the patient is concerned , this procedure is sure and noninvasive . despite these advantages ,
they are characterized by very poor contrast , blended contours , and the human body complexity is responsible for the fact that some parts of the image could be partially or completely hidden by other organs . in a medical context
it is crucial to develop efficient applications with a reduced execution time , especially in the case of urgent diagnosis .
to do so , one can imagine to use a parallel - based architecture such as cluster , grid computing , graphics processing units ( gpus ) .
however , such a solution does not exploit the cpu multiple computing units ( cores ) present in the majority of computers .
moreover , the solution based on gpu is seriously hampered by the high costs of data transfer between cpu and gpu memories .
to limit these constraints , we propose a parallel hybrid implementation which allows exploiting effectively the full computing power of heterogeneous architectures .
indeed , we develop a parallel hybrid implementation of the recursive contour extraction technique using canny 's criteria .
our choice to parallelize this method is due to its noise robustness and its reduced number of operations .
these factors allow applying the application on large sets of medical images and enable to have more precise results for vertebra extraction .
therefore , our framework could be used in a medical context given the growing number of patients .
another application could be associated to the search and the navigation in large images and videos databases , such as in .
the remainder of the paper is organized as follows : related works are described in section 2 .  
section 3 presents the cpu implementation of the proposed method based on active shape model .  
section 4 discusses the use of gpu for image processing algorithms , while section 5 is devoted to the parallel hybrid implementation of our approach , exploiting effectively the full computing power of heterogeneous architectures .  
section 6 presents the obtained results of vertebra extraction using a data set of medical images and compares the performance between cpu , gpu and hybrid implementations .
  one can find two kinds of related work for which vertebra segmentation and optimal edge detection in medical images are the fundamental processing steps : the first one is related to sequential solutions for vertebra extraction using cpus , and the second is related to the use of gpu to accelerate image processing algorithms , which can be exploited for medical applications .   
if we study the segmentation approaches described in the literature , we can observe that their effectiveness depends on the related medical imagery modality .
one can distinguish 3 types of modality : the conventional radiography ( x - ray ) , the computed tomography ( ct ) and the magnetic resonance ( mr ) .
with regard to the mr images , a watershed algorithm has been used in   to segment and reconstruct intervertebral disks . the idea is to provide preoperative data with an image - guided surgery system .
the method uses a combination of statistical and spectral texture features to discriminate closed regions representing intervertebral disks .
recently , huang et al . have used a learning - based approach applied to the vertebra detection and segmentation on mr images . to this end , features such as harr wavelet are extracted on images to train an adaboost learning algorithm .
finally , a normalized graph cut algorithm is used to segment the exact contour of the vertebr .
a similar approach has also been proposed for the vertebra segmentation in the context of ct images . in , lumbar vertebr are segmented by the minimization of the graph cut associated to a ct image . still in this context , the active contour algorithm which deforms and moves a contour submitted to internal and external energies is applied in . in this work ,
klinder et al . provides a framework dedicated to the detection , identification , and segmentation of ct images for the computer - assisted surgery .
concerning the segmentation part , they use a constrained deformable model defined in . in the same idea , the level set method , which makes an interface evolve in the image , has also been dedicated to the vertebra segmentation in [ 9 , 10 ] .
the main drawback of these methods remains the strong influence of an initialization close to the target . to deal with x - ray images , methods
the efficient methods for mr or ct images are not suitable for radiographs because of the blended contours .
an exact segmentation needs additional details about the object of interest . for this reason ,
other model - based methods such as active shape model   and active appearance model   showed their effectiveness .
basically , an active shape model is a statistical model generated from a set of training samples .
a mean shape model is computed and placed near the vertebr of interest on the radiograph .
asm search applies deformations on this mean shape so that it corresponds to the real vertebra contour .
an active appearance model is based on the same principle but introduces a model of the underlying distribution of intensity around the landmarks . in this paper , since we do not need the information about the texture , we decided to use active shape model to characterize and segment the vertebr .
asm and aam have been , respectively , used in [ 1416 ] and [ 1720 ] for the vertebra segmentation . however , the models used are global ones , that is , defined by several vertebr .
the interest of that model is to provide information about the curvature and the dependence between two vertebr . nevertheless ,
in the context of the vertebral mobility analysis , the global models can not explain all the curvature variability since 3 particular patient 's positions are studied .
however , in order to ensure an exact contour extraction , we need to precisely initialize the segmentation step by placing mean shape very close to the vertebr of interest . in the literature ,
, the authors try to take advantage of the ght on radiographs in a fully automatic way , but they present a segmentation rate equal to 47% for lumbar vertebr without providing information about the detection rate . very recently ,
dong and zheng have proposed a method combining ght and the minimal intervention of a user with only 2 clicks in the image .
many image processing and rendering algorithms are known by their high consumption of both computing power and memory .
beyond of image rendering , most of image processing algorithms contain phases which consist of similar calculations between image pixels .
these facts make these algorithms prime candidates for acceleration on gpu by exploiting processing units in parallel . in this category , yang et al .
openvidia project   has implemented different computer vision algorithms running on graphics hardware such as single or multiple graphics processing units , using opengl , cg , and cuda .
there are also some gpu works in medical imaging for new volumetric rendering algorithms [ 30 , 31 ] and magnetic resonance ( mr ) image reconstruction on gpu .
otherwise , there are different works for the exploitation of heterogeneous architectures of multicores and gpus .
starpu   provides a unified runtime system for heterogeneous multicore architectures ( cpus and gpus ) , enabling to develop effective scheduling strategies . actually , our contribution is to propose firstly an original automated approach to detect the vertebra location in a radiograph which will be used for the initialization of the segmentation phase .
next , we develop a model - based segmentation procedure especially adapted to the vertebral mobility study .
we also contribute with improving performance of vertebra segmentation in x - ray medical images , by implementing the most intensive step of the proposed approach on heterogeneous architectures composed of both cpus and gpus .
indeed , we propose a parallel hybrid implementation of edge detection step using deriche - canny method   that enables a better noise removing and requires a less number of operations than canny method .
this hybrid implementation allows an efficient exploitation of the full computing power of heterogeneous architectures ( multi - cpu / multi - gpu ) and enables to more improve performance than the gpu implementation described in .
  in this paper , we propose an original approach for the vertebra segmentation in the context of the vertebral mobility analysis .
global statistical models generally used in the literature are not able to explain the spine curvature variability induced by the 3 positions : extension , neutral , and flexion .
therefore , we decided to use a local vertebra model implying an exact initialization of the asm - based segmentation , that is , placing the mean shape close to the vertebr of interest .
for that matter , we need to locate the position of all the vertebral bodies . to this end
actually , the anterior corners of each vertebra are located in the radiograph by an approach based on the edge polygonal approximation .
once we have extracted the vertebra position , we can start the segmentation procedure .  
the learning phase starts with the creation of a sample of images . in our case
, we use x - ray radiographs focused on the cervical vertebr   c3 to c7 ( see figure 2 ) .
actually , each item of the sample has to be described by an information , that is , the coordinates of some landmarks located on the item contour . these points need to correspond on the different shapes in the sample .
every shape in the sample has particular position and orientation . building a relevant statistical model requires to align the shapes .
to this end , we use an alignment approach based on the procrustes analysis and detailed in .  
as soon as all the vertebra shapes are aligned , they can be used to build the active shape model . to do so ,
the mean shape is first computed and then a group of other allowable shapes is derived by moving the landmarks in specific directions , obtained by a principal component analysis ( pca ) of the data .
we refer the reader to   for more detail about the modelization .   in order to initialize the segmentation procedure
, the mean shape has to be placed close to a vertebra of interest . in
, we proposed an original method to locate points of interest in a radiograph . here , we use part of this work but we also detect the vertebr by their anterior corners .
first , a user is asked to mark out 2 points in the image to determine a region of interest ( roi ) by the higher anterior corner of the c3 vertebra and the lower anterior corner of the c7 vertebra .
then , all the vertebral bodies are detected with a process composed of 4 steps : a contrast - limited adaptive histogram equalization to improve the image contrast , an edge detector , an anterior corner detection , and finally the vertebra localization .   
the x - ray images we deal with have very poor contrast . before any further process
therefore , we propose to use a specific method : the contrast - limited adaptive histogram equalization .
the principle is to divide the image in contextual regions . in each of them ,
to get rid of this effect , a bilinear interpolation scheme is used . let a , b , c , and d be the centers of contextual regions ( see figure 1 ) . for a pixel pi with an intensity r , we can write  
 ( 1)s=(1y)[(1x)ta(r)+xtb(r ) ]  + y[(1x)tc(r)+xtd(r ) ] 
									 where tk stands for the equalization transformation of the region k , and s for the new value of the pixel pi .    
only applying this scheme is still dependent to the increase of the noise in the radiograph .
one way to decrease it is to reduce the contrast improvement in the homogeneous areas .
a contrast factor is then defined to limit the highest peaks in the equalized histogram .
the pixels above this factor limit are uniformly redistributed in the histogram .   the canny edge detector , introduced in   allows to detect edges in an image by taking advantage of the information given by the intensity gradient .
the first step is to reduce the noise by removing isolated pixels . to this aim ,
the operator is based on a couple of masks defined by the relation ( 3 ) . with this information ,
the gradient of a pixel can be computed by  
 ( 3)gx=(101202101)a  gy=(121000121)a , 
 ( 4)g = gx2+gy2 , 
  additional information about the gradient orientation is simply given by :   once the gradient has been computed for every pixel , only maxima have to be retained .
high and low thresholds are defined in such a way that , for each pixel , if the gradient intensity is    lower than the low threshold , the point is rejected , greater than the high threshold , the point is part of the edge ,   between the low and the high thresholds , the point is accepted only if it is connected to an already accepted point .   in this work ,
we propose to locate the vertebr by firstly detecting some features : the anterior vertebra corners . to this end
, we present a method based on the geometrical definition of a corner ; that is , a point is considered as a corner if it is located at the intersection of two segment lines .
usually , works about the polygonal approximation detect the dominant points in the image and build a polygonal approximation .
here , we do the opposite by using the polygonal approximation to detect features in the image .
the canny algorithm provides the edges on the image but only acts on the pixel values . in order to carry out the polygonal approximation algorithm
the algorithm used in this paper is the one proposed by douglas and peucker in .
this approach is based on the principle that a polyline represented by n points can be reduced in a representation with 2 points if the distance between the segment line joining the extremities of the polyline and the farthest point from this line is lower than a given threshold .
the first stage concerns the selection of the extremities e1 and e2 of the polyline .
let a be the farthest point from the segment line ||e1e2|| and d the distance between the point a and ||e1e2|| .
three scenarios are considered :    if d   , all the points situated between e1 and e2 are removed , if d >  , the algorithm is recursively applied on 2 new polylines : ||e1a|| and ||ae2|| ,   if there is no point between e1 and e2 , the polyline is no longer reducible .  
now that we have detailed how to detect corners in a general way , let us explain how to only detect the vertebra ones .
among all the corners detected by our approach based on the edge polygonal approximation , the ones describing a vertebra need to be distinguished .
the first stage of our procedure is to build a statistical model of the spine curvature in order to extract the mean shape .
notice that here , the goal is not to explain precisely the curvature but just to have a way to locate vertebra anterior corners .
the next step brings a user to mark out the higher anterior corner of the c3 vertebra and the lower anterior corner of the c7 vertebra to define a roi .
then , we perform an alignment between these two particular points and the mean shape of the spine curvature model . finally , for each landmark , we search the closest corner detected by the approach based on the edge polygonal approximation .
note that a specific order has to be followed : from the top to the bottom of the image ( the opposite could be considered ) .
this order is crucial to avoid the algorithm swapping lower and higher corners of two successive vertebr .  
the statistical model allowing to identify acceptable shapes of the object of interest is now defined .
however , we still have to present how the search in the image is conducted during the segmentation . to this end
, the grey level variation has to be locally evaluated around each landmark in the sample .
then , a mean profile of the texture ( gradient intensity ) can be deduced .
after the initialization , a local analysis of the texture is carried out around each landmark of the initial shape .
the procedure is repeated until the convergence , that is , when the match between the current shape profile and the mean one is no more improved .
image processing algorithms represent an excellent topic for acceleration on gpu , since the majority of these algorithms have sections which consist of a common computation over many pixels .
this fact is due to the exploitation of the high number of gpu 's computing units in parallel . as a result
, we can say that graphics cards represent an efficient tool for boosting performance of image processing techniques .
this section describes firstly the key factors of gpus and the programming languages used to exploit their high power and secondly the proposed development scheme for image processing on gpu , based upon cuda for parallel constructs and opengl for visualization .
graphics processing units ( gpus ) have dramatically evolved during last years as shown in figure 3 .
this evolution makes them a very high attractive hardware platform for general purpose computation . for a better exploitation of this high power ,
furthermore , the advent of gpgpu ( general purpose graphics processing unit ) languages enabled exploiting gpu for more types of application and not only for image rendering and video games . in this context
, nvidia launched the api cuda ( compute unified device architecture ) , a programming approach which exploits the unified design of the most current graphics processing units from nvidia . under cuda , gpus consist of many processor cores which can address directly to gpu memories .
, cuda has rapidly gained acceptance in domains where gpus are used to execute different intensive parallel applications .   
we propose in this paragraph a model for image processing on graphics processors , enabling to load , treat , and display images on gpu .
this model is represented by a scheme development based upon cuda for parallel constructs and opengl for visualization , which reduces data transfer between device and host memories .
this scheme is based on four steps ( figure 4 ) : parallel processing with cuda ,  
 copy input data : the transfer of input data ( images ) from host ( cpu ) to device ( gpu ) memory enables to apply gpu treatments on the copied image . 

threads allocation : after loading the input data ( images ) on gpu memory , the threads number in the grid of gpu has to be selected so that each thread can perform its processing on one or a group of pixels .
we note that the selection of the number of threads depends on the number of pixels . 
 parallel processing with cuda : the cuda functions ( kernels )
output results : after processing , results can be presented using two different scenarios . 


opengl visualization : the visualization of output images using the graphics library opengl is fast , since it exploits buffers already existing on gpu .
indeed , the compatibility of opengl with cuda enables to avoid more data transfer between host and device memories .
this scenario is useful when parallel processing is applied on one image only since we can not display many images using one video output ( one gpu disposes of one video output ) . 

transfer of results : the visualization with opengl is impossible in the case of applying treatments on a set of images using one video output only . in this case
, the transfer of results ( output images ) from gpu to cpu memory is required .
opengl visualization : the visualization of output images using the graphics library opengl is fast , since it exploits buffers already existing on gpu .
indeed , the compatibility of opengl with cuda enables to avoid more data transfer between host and device memories .
this scenario is useful when parallel processing is applied on one image only since we can not display many images using one video output ( one gpu disposes of one video output ) .  

transfer of results : the visualization with opengl is impossible in the case of applying treatments on a set of images using one video output only . in this case , the transfer of results ( output images ) from gpu to cpu memory is required .
  we presented in section 3 the implementation details and steps of the proposed method of vertebra extraction on cpu .
one disadvantage of this method is the computing time which increases significantly with the number of images and their resolution .
actually , the execution time of the edge detection is approximately 3 or 4 times greater than the time for histogram equalization and polygonal approximation .
the asm search procedure is not adapted for a parallel implementation due to the number of iterations which are dependent with each other .
we proposed in   a solution based on the exploitation of the high power of gpus in parallel .
however , this solution does not exploit the cpu multiple computing units ( cores ) present in the majority of computers .
moreover , the solution based on gpu is hampered by the costs of data transfer between cpu and gpu memories .
to reduce these constraints , we propose a parallel hybrid implementation which allows exploiting effectively the full computing power of heterogeneous architectures ( multi - cpu / multi - gpu ) .
this implementation is applied on the most intensive step of the vertebra segmentation method : edge detection .
this section is presented in two parts : the first part describes our gpu implementation of edge detection step based on a recursive method .
this section describes the gpu implementation of edge detection step based on a recursive algorithm using canny 's design .
the noise truncature immunity and the reduced number of required operations make this method very efficient .
this technique is based on four principale steps : recursive gradient computation ( gx , gy ) .  
we note that the recursive gradient computation step applies a gaussian smoothing before filtering the image recursively using two sobel filters in order to compute the gradients gx and gy . while the steps of gradient magnitude and direction computation , nonmaxima suppression , and hysteresis represent the same steps used for canny filter described in section 3.3.2 .
the proposed gpu implementation of this recursive method is based on the parallelization of all the steps listed below on gpu using cuda .
the gpu implementation of the recursive gaussian smoothing step is developed using the cuda sdk individual sample package .
the advantage of this method is that the execution time is independent of the filter width .
the use of this technique for smoothing allows to have a better noise truncature immunity which represents an important requirement for our application .
the recursive gpu implementation of this step is provided from the cuda sdk individual sample package .
this step applies a convolution of the source image by two sobel filters of aperture size 3 in order to compute horizontal and vertical gradients gx and gy at each pixel .
the gpu implementation is based firstly on a parallel horizontal convolution across the columns for computing gx and secondly on a parallel vertical convolution across the lines for computing gy .
once the horizontal and vertical gradients ( gx and gy ) have been computed , it is possible to calculate the gradient magnitude ( intensity ) using ( 4 ) and the gradient direction using ( 5 ) .
the cuda implementation of this step is applied in parallel on image pixels , using a gpu grid computing containing a number of threads equal to image pixels number .
thus , each thread calculates the gradient magnitude and direction of one pixel of the image . after computing the gradient magnitude and direction
, we apply a cuda function ( kernel ) which enumerates the local maxima ( pixels with high gradient intensity ) and deletes all nonridge pixels since local maxima are considered as a part of edges .
we proposed to load the values of neighbors pixels ( left , right , top , and bottom ) in shared memory , since these values are required for the search of local maxima .
the number of selected threads for parallelizing this step was also equal to image pixels number .
any pixel in the image that has a gradient magnitude greater than t1 is presumed to be an edge pixel and is marked as such immediately .
then , all the pixels connected to this edge pixel and that have a gradient intensity greater than t2 are also selected as edge pixels .
notice that we exploit also the gpu 's shared memory for a fast loading of connected pixels values .
the gpu implementation described below allowed to improve considerably the performance of edge detection step in the case of processing one image only , since results can be visualized quickly with opengl .
however , if we apply treatments on a set of medical images ( as required in our proposed method of vertebra detection ) , the transfer of results ( output images ) from gpu to cpu memory will be required .
thus , we propose to implement the edge detection step on a set of medical images , by exploiting the full computing power of heterogeneous architectures ( multi - cpu / multi - gpu ) that enables to have faster solutions , with less transfer of data between cpu and gpu memories , as the images processed on cpu do not require any transfer .
the proposed implementation is based on the executive support starpu   which provides a unified runtime system for heterogeneous multicore architectures .
therefore , our hybrid implementation of the edge detection step applied on a set of x - ray images can be described in three steps : loading of input images , hybrid processing with starpu , and updating and storing results .
first , we have to load the input images in queues so that starpu can apply treatments on images present on these queues .  
1  for ( 
 i = 0 ; i < n ; + + i ) { n : number of images 
 2   img = cvloadimage ( input_image } ; 
											
 3   starpu_data_handle img_handle ; 

 4   starpu_vector_data_register(&img_handle ) ; 

 5   queue = add(queue ,  img ,  img_handle ) ;  

 6  } 
 
 1  for ( 
 i = 0 ; i <
n ; + + i ) { n : number of images 
 2   img = cvloadimage ( input_image } ; 
											 
 3   starpu_data_handle img_handle ; 
 
 4   starpu_vector_data_register(&img_handle ) ; 
 
 5   queue = add(queue ,  img ,  img_handle ) ;  
  line 2 allows loading the image in main memory , lines 3 and 4 enable to allocate a buffer ( handle ) starpu which disposes of the loaded image address .
line 5 is used to add this image and the buffer starpu in a queue that will contain all the images to treat .
once the input images are loaded , starpu can launch the cpu and gpu functions of edge detection ( described , respectively , in section 3.3.2 and 5.1 ) on heterogeneous processing units ( cpus and gpus ) .
the codelet defines the computing units that could be exploited ( cpus or / and gpus ) , and the related implementations ( listing 2 ) .
1   static starpu_codelet cl = { 
 2  .where = starpu_cpu|starpu_cuda ,   // cpu & gpu cores 

 3  .cpu_func = cpu_impl ,   // define cpu fct 

 4  .cuda_func = cuda_impl ,  //
buffers number 

 6  } ; 
 
 1   static starpu_codelet cl = { 
 2  .where = starpu_cpu|starpu_cuda ,   //
buffers number 
  in our case , each task is created and launched to treat one image in the queue .
the scheduler of starpu distributes automatically and effectively the tasks on the heterogeneous processing units .
starpu enables also an automatic transfer of data from cpu to gpu memory if tasks are executed on gpu .
when all the starpu tasks are completed , the results of gpu treatments must be repatriated in the buffers .
this function enables also to transfer data from gpu to cpu memory in the case of treatments applied on gpu . 

submission of tasks to the set of images . 
 1  while ( queue ! = null )  { 
 2  task = starpu_task_create ( ) ;  //create task 

 3  taskcl =   & cl ;  //define the codelet 

 4  taskhandle = queueimg_handle ;  //define the buffer 

 5  taskhandle.mode = starpu_rw ;  //mode read / write  

 6  starpu_task_submit(task ) ;  //submit the task 

 7  queue = queuenext ;  //move to next image 

 8  } 
 
 1  while ( queue ! = null )  { 
 2  task = starpu_task_create ( ) ;  //create task 
 
 3  taskcl =   & cl ;  //define the codelet 
 
 4  taskhandle = queueimg_handle ;  //define the buffer 
 
 5  taskhandle.mode = starpu_rw ;  //mode read / write  
 
 6  starpu_task_submit(task ) ;  //submit the task 
 
 7  queue = queuenext ;  //move to next image 

the validation of the cervical mobility evaluation is made by the validation of the segmentation approach .
if we can be sure to know exactly the contour of the vertebr , we can efficiently evaluate the angles between them . in order to do this
, we use a sample of 51 radiographs coming from the nhanes ii database of the national library of medicine ( http://archive.nlm.nih.gov/proj/dxpnet/nhanes/nhanes.php ) .
interesting data in this work are radiographs focused on the cervical vertebr . actually , we study the 5 vertebral bodies c3 to c7 .
note that the resolution is the same for all images , that is , 1763  1755 pixels .
we then chose randomly 51 x - ray films allowing the visual presence of the vertebr c3 to c7 .
one way to measure the segmentation error is to compute the distance between the asm contour and a theoretical contour defined by a specialist .
therefore , a gold standard has been defined for the 51 radiographs of the test set .
the chosen distance for measuring the segmentation error is the point - to - line distance .
used in [ 15 , 16 ] , the principle is to compute the length of the perpendicular dropped from each landmark of the theoretical contour to the spline evaluated between the landmarks of the asm contour .
a visual representation of the point - to - line distance is provided at the figure 5 .  
the reader will find the mean error ( in px ) for the sample of 51 radiographs , the median ( in px ) , and finally the failure rate .
however , the scanner used by the nlm to digitize the radiographs was of 146  dpi . therefore , we can consider that 1  px is approximately equal to 0.2  mm . in order to determine the failure rate , we followed the example presented in .
therefore , we consider as a failure any error greater than 3 standard deviations from the mean of the success distribution . before the analysis of the segmentation results , we need to measure the quality of the initialization based on the detection of the vertebr in the radiograph .
as we previously noticed , the goal of detecting corners in cervical spine radiographs is to initialize the mean shape of the asm search . in
, we showed the benefits of the polygonal approximation dedicated to the points of interest detection by comparing it with the harris detector .
the harris and stephen 's definition of a corner uses the information of the hessian matrix of grey level intensities .
this detector is based on the local autocorrelation matrix of a signal on a region defined around each point , which measures the local changes of the signal in different directions .
however , the results show that in the particular context of cervical spine radiographs , the intensity gradient information is not useful for detecting the points of interest . actually , we demonstrate the interest of using a geometrical definition of a corner for its detection .
another advantage of the polygonal approximation is that once the canny parameters have been chosen , only one parameter remains to be fixed : the threshold . furthermore , there is no influence between the canny parameters and the one of the polygonal approximation . in this section ,
in fact , it was asked him to mark out manually all the vertebr on the radiograph .
we used a distinctive model for each vertebra level . in the literature [ 1720 ] , the models used are global ones .
their advantage is to bring information about the spine curvature , but they can not efficiently accomplish a local segmentation .
the only way to do this is to use a local vertebra model , but it requires a precise initialization close to the object of interest .
the segmentation error is about 2.90  px and the percentage of failures is more than acceptable for each vertebra level ( compared to the literature , see , for instance [ 15 , 1720 ] ) .
we could have stopped the experiments here , but it is not conceivable to ask a user to mark out all the vertebr on every image he has to segment . for this reason ,
one of the contributions of this paper is to propose a semi - automatization of the asm initialization .
the data related to the table 2 present the results based on this automated initialization . the analysis of the table demonstrates two particular trends .
first , if we consider the mean segmentation error , we notice that its value is slightly increased in comparison with the   table 1 . a meticulous analysis permits to target the step of the procedure responsible for this phenomenon . in fact , the results degradation is due to the points of interest detection by the polygonal approximation
. nevertheless , this effect is minimal if we look at the results of the table 2 .  
if two vertebr are merged , the corner detection could confuse a higher corner of a vertebra with the lower corner and the adjacent vertebra .
finally , we give the user a visual illustration of the whole framework to perform the vertebra segmentation at the figure 6 . on the one hand
, we can say that the quality of the vertebra segmentation remains identical since the procedure has not changed . only the architecture and
on the other hand , the exploitation of heterogeneous architectures ( multi - cpu / multi - gpu ) in parallel for vertebra extraction enabled to accelerate the computation time .
this acceleration is due to the hybrid implementation for edge detection step based on a recursive method using deriche - canny method . this fact allowed to apply our proposed method on large sets of x - ray medical images in order to have more precision for vertebra detection results . 

figure 7(a ) presents the comparison of the computing times between sequential ( cpu ) , parallel ( gpu ) , and hybrid ( multi - cpu / multi - gpu ) implementations of the edge detection step , applied on a set of 200 images using different resolutions .  
the accelerations presented at figure 7 are due to two level of parallelism : a low - level and a high - level parallelization . a low - level parallelization by porting the edge detection step on gpu ( parallel processing between pixels in image : intraimage parallel processing ) .   a high - level parallelization ( interimages parallel processing ) enabling to exploit simultaneously both cpus and gpus cores so that each core treats a subset of images .     
experimentations have been conducted on several platforms , that is , gpu tesla c1060 and cpu dual core :    cpu : dual core 6600 , 2.40  ghz , 2  gb ram of memory .  
gpu : nvidia tesla c1060 , 240  cuda cores , 4  gb of memory .
in this paper , we proposed a framework for vertebra segmentation based on a local statistical model . an original process in order to locate vertebr in a radiograph has been developed .
the extraction procedure is composed of 4 steps : a contrast - limited adaptive histogram equalization to improve the image contrast , an edge detection , an anterior corner detection , and finally the vertebra localization .
generally , the computation time and noise immunity truncature represent the most important requirements in medical image processing and specifically for our application .
the graphics processors provided a solution by exploiting the gpu 's computing units in parallel .
however , this solution is hampered by the costs of data transfers between cpu and gpu memories .
thus , we proposed a parallel hybrid implementation of the recursive edge method using deriche - canny approach .
moreover , this solution requires a less transfer of data between cpu and gpu memories , as the treatments on cpu do not require any transfer . as future work
, we plan to develop a fully automatic segmentation approach based on a learning method such as support vector machine ( svm ) .
we also aim to provide an automatic parallel implementation exploiting the full computing power of hybrid architectures .
this implementation could choose automatically the processing units for each step of our medical application .
thus , the most intensive steps ( initialization : edge detection ) would be implemented on heterogeneous platforms ( multi - cpu / multi - gpu ) , and the less intensive or not parallelizable steps ( learning , modelization , and segmentation ) would exploit the cpu multiple cores ( multi - cpu ) .
 the context of this work is related to the vertebra segmentation . 
 the method we propose is based on the active shape model ( asm ) . 
 an original approach taking advantage of the edge polygonal approximation was developed to locate the vertebra positions in a x - ray image . despite the fact that segmentation results show good efficiency , 
 the time is a key variable that has always to be optimized in a medical context . 
 therefore , we present how vertebra extraction can efficiently be performed in exploiting the full computing power of parallel 
 ( gpu ) and heterogeneous ( multi - cpu / multi - gpu ) architectures . 
 
 we propose a parallel hybrid implementation of the most 
 intensive steps enabling to boost performance . 
 experimentations 
 have been conducted using a set of high - resolution x - ray medical 
 images , showing a global speedup ranging from 3 to 22 , by 
 comparison with the cpu implementation . 
 data transfer times 
 between cpu and gpu memories were included in the execution 
 times of our proposed implementation . 
1. Introduction
2. Related Work
3. General Framework
4. Image Processing on GPU
5. Hybrid Implementation on Heterogeneous Architectures
6. Experimental Results
7. Conclusion