Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

I have a 3-channel image which shows red and green points (certain labelled proteins) inside blue regions (cell nuclei). After applying some segmentation filters, the resulting image is as follows: enter image description here

The regions circled in blue are separated into components following steps similar to those mentioned in this guide Count Cells

The red and green points are also both separated into components. What would be the best way to count those red and green points which are bound by the blue components?
-EDIT- What I mean is counting the points per blue-bound area, not the entire image as a whole. Sorry for the confusion. A rather brute-force method would be to call SelectComponents with a Do loop using the Label attribute of the components and use that as a mask. Is there a better and more efficient method of doing this?

Do[mask = 
   Image[SelectComponents[nuclei, "Label", # == nucList[[i]] &]]; 
  redFoci = 
   ComponentMeasurements[
    SelectComponents[ImageMultiply[redChan, mask], "Count", 
     2 < # < 100 &], "Centroid"]; 
  greenFoci = 
   ComponentMeasurements[
    SelectComponents[ImageMultiply[greenChan, mask], "Count", 
     2 < # < 100 &], "Centroid"]; 
  AppendTo[fociList, {Length[redFoci], Length[greenFoci]}];
  , {i, Length[nucPos]}];
Print[fociList];
share|improve this question
    
Have you seen Markus' presentation here? –  cormullion Aug 5 '13 at 10:48
    
I have viewed it, but it did not appear to have any insights on how to solve this question. –  March Ho Aug 6 '13 at 1:20

1 Answer 1

up vote 2 down vote accepted

Here's another way to do what I think you want to do. I don't know how it compares to your method. A lot of the code is for various visualizations. It could be pruned to just get the information you need.

Explanation of the procedure

It's difficult to calculate the number of red and green components for each cell because each cell is not clearly demarcated. Sometimes their boundaries blur together or aren't self-enclosed. My strategy ended up being this:

  1. Find the boundaries by extracting all blue pixels
  2. Fill small gaps by dilating the boundaries and then narrowing them down again.
  3. Use the filling transform to extract the pixels inside each boundary
  4. Neighboring cells will blur together if they share a boundary. By adding back the boundaries on top after filling, the cells are again separated.

The problem is this way of filling small gaps cannot be used to fill larger ones, and so those cells won't be recognized as cells at all. This image demonstrates this:

boundaries

The white boundaries correspond to blue pixels. The colored areas are cells, they are recognized by MorphologicalComponents because they have been sufficiently separated by the method described above. As one can see, this works for almost all cells.

Now, all we have to do is look at each component and extract the red and green pixels respectively, then use MorphologicalComponents and ComponentMeasurements to figure out how many of each type there is.

The Code

extractColor[img_Image, col : "Red" | "Green" | "Blue"] := 
  Module[{c = col, i = img, sep},
   sep = ColorSeparate[i];
   If[c == "Green", sep = RotateLeft[sep]];
   If[c == "Blue", sep = RotateRight[sep]];
   ImageSubtract[ImageSubtract[#1, #2], #3] & @@ sep
   ];
healingBrush[img_Image, brushSize_] := 
 Binarize[Thinning[Dilation[img, DiskMatrix[brushSize]]], 0.1]
countClusters[
  img_Image] := (ComponentMeasurements[MorphologicalComponents[#], 
      "LabelCount"] & /@ {extractColor[img, "Red"], 
     extractColor[img, "Green"]})[[All, 1, 2]]

img = Import["http://i.stack.imgur.com/n6Eit.png"];

borders = healingBrush[extractColor[img, "Blue"], 1];
components = 
 MorphologicalComponents[
   ImageMultiply[ColorNegate[Dilation[borders, 0.5]], 
    FillingTransform@borders]] // Colorize

Show[components, 
 ColorNegate@SetAlphaChannel[ColorNegate@borders, borders]]

isolatedComponents = 
  ComponentMeasurements[
    components, {"Centroid", "Mask"}] /. (i_ -> {l_, m_}) :> {i, l, 
     countClusters[ImageMultiply[img, Image[m]]]};

Show[img, 
 Graphics[{White, 
   Text["R: " <> ToString[#[[3, 1]]] <> "\nG: " <> 
       ToString[#[[3, 2]]], #[[2]]] & /@ isolatedComponents}]]

Final result

result

The data used for this visualization is stored in isolatedComponents.

(Someone who'd want to use this would be wise to count manually for a few cells and compare the result. I did not do this.)

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.