AW: [Insight-users] Silly Question!! : FloodFill vs FastMarching

[Luis Ibanez]

Hi Zein

FastMarching is faster than FloodFill if you
count the time from the point in which you
have your speed image ready.

In practice, the preprocessing required for
obtaining an appropriate speed image is taking
most of the time of a segmentation process based
on FastMarching.

If you look at the collaboration diagram in
Figure 8.10 of the SoftwareGuide. (pdf-page 264).
http://www.itk.org/ItkSoftwareGuide.pdf
You will see that two or three filters are typicaly
applied as preprocessing. These filters may take
80% to 90% of the whole segmentation time.

It is not easy to generalize judgements about LevelSet
algorithms since there are so many variants of them
and so many parameters to tune on each one.

For one thing, most of the LevelSet methods are iterative.
Hence, you can run them for as many iterations as you want.
Only a careful selection of parameter may produce acceptable
results in the early iterations of the process.

The complexity of the shape to be segmented is also a factor
to be considered when you want to compare these two types of
methods. Flood fill filters (at least those implemented in
ITK) do not take any morphological information into account.
They are henceforth appropriate for simple segmentation cases.
LevelSets on the other hand, allow to consider curvature
restrictions (among others) during the segmentation process.

This means that you can only compare these methods in the
context of a well defined application and subject to a
particular selection of parameters.

At the end you could say something like:

     FloodFill with this set of parameters X

     is (faster/slower) than

     FastMarching with this set of parameter Y

     when used for segmenting the specify image Z


---

Regards,


    Luis


-------------------------------
salah wrote:
> Thanks Luis for the detailed discussion.
> 
> I also think, as long as the algorithm is not parallely
> implemented, It would make that much difference. The choice 
> between a LIFO or a FIFO container (a stack or a queue) 
> would only affect the direction of the traversal, i.e,
> depth-first or breadth-first, and not its speed 
> 
> If the algorithm were parallely implemented, i.e, if it 
> could make use of a parallel machine, then a breadth-first
> floodfilling (with FIFI container) would be faster for multiple 
> initial seeds. Of course the implementation of the algorithms
> in this case would not be that simple. 
> 
> I have noticed some other interessant thing in your email.
> 
> "From the fact side. We know that something like the
> FastMarchingLevelSet method will run faster than the
> current flood fill implementation, and we probably say
> hat both things are 'region growing' methods."
> 
> Are FastMarchingLevelSet really faster than the flood-fill-
> based region-growing segmentation filters ??? I tried to use 
> level set algorithms sometime in the last year and stopped,
> just because I found them slow !!
> 
> Regards,
> 
> Zein
> 
> 
>