Visualization of tracks of objects in images by superposition

Question

I have sets of images (each contains about 3000 images where many objects are seen, each image is 4 Megapixels large, format is 8bit, gray scale, png).

To get an impression about the trajectories of the objects I superpose all images and produce a single colorized image where the objects in each image have a specific color corresponding to the image number.

The background ist black, the tracks start with blue and stop with red.

The problem in the code below is that it crashes when many and larges images are used since all of them are read at once in memory.

Is there a solution that image by image can be read and superposed on top of each other, instead of reading them at once?

example image that contains only a single object:

a sample of small images for testing the code: http://tinyurl.com/ht5362l

code:

ChoiceDialog[{FileNameSetter[Dynamic[imageDir], "Directory"], Dynamic[imageDir]}];
SetDirectory[imageDir];

fNames = FileNames["*.png"];
numImages = Length[fNames];

colTable = {
   {Black}, 
      Table[
         {Blend[{Blue, Green, Yellow, Red}, x]}, 
         {x, 2/numImages, 1, 1/numImages}
      ]
}; 

colTable = Flatten[colTable];

threshold = FindThreshold[Import[fNames[[1]], Method -> "Entropy"]];

bins = Table[
          Clip[
             Import[fNames[[i]], "GrayLevels"], {threshold, threshold}, 
             {0, i/numImages}
          ], 
          {i, 1, numImages}
       ];

superImg = Colorize[
              Image[
                 Map[Max, Transpose[bins, {3, 1, 2}], {2}]
              ], 
              ColorFunction -> (Blend[colTable, #] &)
           ]

superposed image:

Answer 1

Just assemble the bins image one layer at a time. E.g. after computing threshold do

bins = 0;
Do[
  m = Clip[Import[fNames[[i]], "GrayLevels"], {threshold, threshold}, {0, 1}];
  bins = bins (1 - m) + m i/numImages,
  {i, 1, numImages}];

superImg = Colorize[Image[bins], ColorFunction -> (Blend[colTable, #] &)]

Answer 2

I propose making use of ComponentMeasurements, especially the "Centroid"-Option of MorphologicalComponents, which calculates the center-of-mass, might be very convenient.

For example you might try the following:

SetDirectory[imageDir]
i = Import["2016071.gif"];
length = Length[i];
m[y_] := Module[{y0}, y0 = y;
  iframe = i[[y]];
  (*Poisson-Filter blures the image, edges are contained*)
  res = TotalVariationFilter[iframe, 0.35, Method -> "Poisson"];
  mean = ImageMeasurements[iframe, "MeanIntensity"];
  ib = MorphologicalBinarize[res, {mean + 0.5}];
  (*Delete Small Components  if necessary!*)
  delsmall = DeleteSmallComponents[ib, 10];
  t = MorphologicalComponents[delsmall] // Max;
  m1 = ComponentMeasurements[MorphologicalComponents[delsmall], 
     "Centroid"] /. Rule[_, x_] -> x;
  imageBuffer = iframe;
  If[y == 1, pointsbuffer = SetAlphaChannel[iframe, 0], 
   pointsbuffer = pointsbuffer;
   (*In each frame a loop will set dots a each com-
   position calculated*)
   For[p = 1, p < t + 1, p++, Print[p];
     points = 
      Show[pointsbuffer, 
       Graphics[{PointSize[0.01], ColorData["SolarColors"][y/50], 
         Point[Part[m1, p]]}]];
     pointsbuffer = points]
    (*Print to see the output on-the-fly*)
    Print[Show[iframe, pointsbuffer, ImageSize -> 350]]
    Export["outputDir/img_" <> ToString[y] <> ".png", 
     Show[iframe, pointsbuffer]]
   ]
  ]
(*Run through all frames*)
For[k = 1, k <= length, k++,
 m[k]
 ]

I should notice that I made a .gif out of your images. This code might not be the most efficient or beautiful, since it is written quite quickly. There is definetly room for improvement, but I think it is at least understandable.

My output looks like this (quality is reduced):

P.S. If you want to know more about the procedure itself you might also consider printing "ib", which is the morphologically binarized image. By doing so one can see which component/area is used to calculate the center-of-mass.