Detection / segmentation of cells recorded with phase-contrast microscopy
tmoe...@googlemail.com
first of all you might want to have a look at an example image to get
an idea what I'm talking about: http://img377.imageshack.us/my.php?image=20070117hmsc7pplastict0gu6.jpg
Basically what I'm trying to do is to detect the cells on the picture
and segmentate them from each other. I figured out that this is not
trivial. I already tried two things :
1.) manually building two histograms, one for the cells, one for the
background and then comparing them for each pixel and then classifying
this pixel either as C (cell) or B (background).
2.) some kind of fuzzy thresholding (http://img400.imageshack.us/
my.php?image=bla1zv2.jpg)
Both didn't work out very well. Would be very nice if you could throw
some thoughts / ideas at me. I'm very happy for every response since I
don't know too much about image processing.
If you're curious why I am doing this: in our research lab we try to
automatically track cells over time / image sequences and getting the
path they traveled. I already implemented a model-based tracker using
meanshift but its not working too well. So I figured tracking by
detection / segmentation is maybe the better approach.
Greetings,
Thomas
Pixel.to.life
Thomas,
Have you looked into using a level-set based segmentation? What
approach did you use to implement the model-based-tracker?
See this document for example:
http://meru.cs.missouri.edu/mvl/bio_motion/cellflow/miccai06/miccai06+multi-nuclei.ppt.pdf
Bob
operation to pick up the white areas surrounding the cells.
Here is some matlab code (you're going to need the matlab image
processing toolbox too)
%% read in the image
I = double(rgb2gray(imread('C:\MATLAB701\work\temp\cells.jpg')));
img = imresize(I,0.25);
%% proc it
bw = img>200;
bwcells = imdilate(bw,strel('disk',4));
This is the result:
http://img.villagephotos.com/p/2006-4/1174390/bwcells.jpg
This picks up the cells but also some of the little white specks. You
might get rid of those using the imopen function before the imdilate.
Bob
Pixel.to.life
Seems to work. Is this what you wanted, Thomas?
ImageAnalyst
center of the blobs is the same intensity as the outside of the blob,
plus there are some breaks in the edge (perimeter) of the blob where
the edge goes to the same intensity as the surround. To get around
this, try an edge detector, such as Sobel or a variance filter. This
will get the edges but you will have some breaks around the
perimeter. Then use a morphological closing operation to connect the
edges. Then fill the perimeters. Now you have a binary image of your
blobs and you can continue from there to find outwhat you need. Even
doing this, there are some objects that aren't found correctly. You
can try different edge detection and closing kernel (window) sizes to
see if that improves detection. It can be a tough problem.
Regards,
ImageAnalyst
============================================
Pixel.to.life
>
> - Show quoted text -
Did you look at the processed image Bob shared? It seemed to work.
Even I suggested using level-set based approach initially.. but if a
simple method works why complicate it? Oh wait.. I just noticed. The
image Bob posted is different from what was originally mentioned. Then
I kind of agree with you. In this case, a simple approach like
thresholding will not work. I recommend trying what ImageAnalyst says.
If that doesnt work, look for the links I shared earlier.
Bob
Thresholding almost never works for such images. This is because the
center of the blobs is the same intensity as the outside of the blob,
plus there are some breaks in the edge (perimeter) of the blob where
the edge goes to the same intensity as the surround.
Did you look at the processed image? The cells are surrounded by a
white region that is picked up by thresholding. I then filled in the
center with a morphological operation.
pixel.to.life wrote
> Oh wait.. I just noticed. The
> image Bob posted is different from what was originally mentioned.
Not clear what you mean. The image posted is the processed i.e.
thresholded plus imopen'd image. I downsized by a factor of 0.25 so I
could post it on the villagephotos site.
Bob
Bob
Pixel.to.life
Bob,
In that case, it appears it ended up segmenting a lot more than the
cells. If you look at the original image, the cells have very high
curvature bounary, with concave ridges. In the image you shared, they
seem to have been disappeared. The shape of the cells seems to have
beenlost in the process. No? If you can upload a higher resolution
image (same as original one), perhaps it will be clearer.
It is difficult to accurately delienate the cell boundaries with
simple methods. Your effort is appreciated.
Pixel.to.life
>
> - Show quoted text -
Hi,
I tried detecting edges using Canny technique. It is still difficult.
I didnt try closing operation afterwards, but even within the cells
there seems to be high gradient areas.
If you smooth too much, you lode boundary definition. If you dont, you
get high frequency broken edges:
A cropped 512x512 portion of original image:
http://medicalimagingscience.googlegroups.com/web/Cells.jpg
Edges detected in that image portion:
http://medicalimagingscience.googlegroups.com/web/Cells_Canny_0.3500_0.9500.jpg
HTH,
Pixel.To.Life
tmoe...@googlemail.com
>
> [http://groups.google.com/group/medicalimagingscience]
I've tried two different approaches for the model-based-tracker :
1.) some kind of active contours: http://www.ulb.ac.be/polytech/sln/team/odebeir/preprint_debeir04.pdf
2.) mean-shift: http://www.ulb.ac.be/polytech/sln/research/incubator/debeir_TMI2005.pdf
They didn't work too well for me, especially when the cells connect to
each other or divide.
The method with thresholding + dilating brings up the problem that
cells that are near to each other appear in one big blob.
Pixel.to.life
>
> - Show quoted text -
> cells that are near to each other appear in one big blob.- Hide quoted text -
>
> - Show quoted text -
Hi. I am getting pretty confident that for this case, where cell-
boundaries are like interfaces that keep changing shape as well as
topology (breaking up, merging) over time, a level-sets based approach
will be more fruitful.
If the cells only expand outside with time, a fast-marching based
approach will be most efficient.
If they can also shrink with time, an initial-value based approach
will be useful.
I strongly recommend looking at Prof. Sethian's work at
http://math.berkeley.edu/~sethian/ .
You can then follow an approach from
http://meru.cs.missouri.edu/mvl/bio_motion/cellflow/miccai06/miccai06+multi-nuclei.ppt.pdf
for example.
Prof. Sethian's work is a beautiful approach to formulating moving
(constrained) interfaces, and opens up many practical solutions in the
fields of medical image segmentation among others.
There might still be one challenge here though: the speed function in
level-set approach is mostly image based. So the core of the cells
might confuse an evolving interface too...
HTH,
Bob
>
> In that case, it appears it ended up segmenting a lot more than the
> cells. If you look at the original image, the cells have very high
> curvature bounary, with concave ridges. In the image you shared, they
> seem to have been disappeared. The shape of the cells seems to have
> beenlost in the process. No? If you can upload a higher resolution
> image (same as original one), perhaps it will be clearer.
>
> It is difficult to accurately delienate the cell boundaries with
> simple methods. Your effort is appreciated.
It would be good if the OP could chime in here. His objective seems to
be "to detect the cells on the picture
and segmentate them from each other." I interpreted that as finding
the location (e.g. center) of the individual cells not finding their
detailed outlines. Hence I did not worry about fine details of the
edge.
I agree that cells close to each other are a problem but that could be
reduced by decreasing the size of the structuring element.
Bob
tmoe...@googlemail.com
First of all thanks a lot for you replies.
Yeah, the main objective is to find the centers of the individual
cells and segmentate them from each other. (in order to track the
cells over an image sequence) The problem is, if I decrease the size
of the structuring element, one cell gets split up in several parts.
I've also tried to segmentate the thresholded blobs with a seeded
watershed (did a distance transform first) but I didn't get good
results. The problem is: too large structuring element -> cells close
to each other become one blob which I can't manage to segmentate , too
small structuring element -> one cell becomes several blobs.
Pixel.to.life: That level-set stuff looks very promising, I've also
found an interesting publication using that approach:
http://www.cs.cmu.edu/~lew/PUBLICATION%20PDFs/Cell%20Tracking/CVPRW%202006.pdf
But it seems that the mathematics behind this is too hard for my brain
to understand. After reading it three times I still have no idea what
they are doing.
Pixel.to.life
> But it seems that the mathematics behind this is too hard for my brain
> to understand. After reading it three times I still have no idea what
>
> - Show quoted text -
Hi, Thomas,
In cases when the image is missing information for the intensity and
gradient based methods to work, I have seen people use geometric
models to compensate. Snakes or active contours was one method. Level
set based techniques are the most recent advances in this area that I
know of.
All the mathematics behind this comes from tracking a moving interface
that always moves normal to itself, no tangential movement. Thats it.
The speed with which it moves can be custom defined based on an
application. For a simple case, the speed is image value or gradient
based.
If your objective is long term, to find out a robust solution, I would
recommend studying this approach. I assure you it will be well worth
it. You can start from Prof Sethian's homepage. Also see
http://en.wikipedia.org/wiki/Level_set_method.
I wish I could point you to a simpler approach, but I am not aware of
any that suits your requirements. It mostly helps to study recent
publications in the area to see how other people are approaching
similar problems, as you found one from CMU.
Good luck, and please share your experiences as you go...
Pixel.To.Life.
tmoe...@googlemail.com
>
> I wish I could point you to a simpler approach, but I am not aware of
> any that suits your requirements. It mostly helps to study recent
> publications in the area to see how other people are approaching
> similar problems, as you found one from CMU.
>
> Good luck, and please share your experiences as you go...
>
>
> - Zitierten Text anzeigen -
I'm currently trying to implement the level-set tracker described here
(http://www.cs.cmu.edu/~lew/PUBLICATION%20PDFs/Cell%20Tracking/CVPRW
%202006.pdf) but I don't unterstand the energy equation there, based
on which the level-set function is evolved.
http://img294.imageshack.us/my.php?image=pic2hh1.jpg
I'm currently using a histogram comparison for evolving my level-set
function, but i'm sure its not as good as using the energy equations
to evolve the level-set function.
First try: http://img142.imageshack.us/my.php?image=pic3qb3.jpg