[Amilius]

La verdad que es un sistema complejo (toda una tesis) y es muy difícil que puedas encontrar un módulo listo para contar manchas de una imagen.

Por la descripción del tipo de imagen diría que lo ideal es tratarla como escala de grises (8bits de profundidad de color, lo que da 256 niveles de gris que van de 0 a 255).

Tengo una idea simple para solucionar el problema:
cada punto vale de 0 a 255:
0=negro ,255=blanco

Eliges un punto al azar de la imagen que no esté revisado, si es más bajo que cierto umbral vas marcando esa zona en espiral (como revisado) hasta que los pixeles tengan valor más alto que otro umbral. Cuentas como 1 mancha y mides su tamaño de acuerdo al área que pintaste antes de decidir que los pixeles restantes no formaban parte de la mancha. Continuas este proceso hasta que no existan áreas de la imagen no marcadas como "revisadas".

Esto servirá si y sólo si: las manchas son circulares, la mancha más pequeña tiene un buen tamaño en pixeles, tienen buen contraste y el contraste entre manchas y fondo es constante y el fondo es también de matiz constante.

Para dar mayor potencia a un sistema de tratamiento de imágenes te recomiendo investigar algunas herramientas matemáticas como el análisis wavelet, ideal para imágenes, que permiten analizar la imagen a varias escalas y permiten realizar detección de bordes también a varias escalas, lo que también es util para eliminar frecuencias muy bajas de la imagen (gradientes en el fondo) para mejorar los resultados.

=P

Creo que escribi demasiado...

P.D.

Esto es para los que alguna vez intentaron hacer algo con "Pixels" y vieron que era muuuuuuuy lento:

/*
Esto es muchísimo más rápido que usar Pixels[x,y] (Realmente mucho más rápido), pero también más complicado y PELIGROSO, no vayan a escribir fuera del area de memoria de su bitmap!!.

OJO que el bitmap va de 0 a Height-1 y de 0 a width-1, no se salgan de límites !!
*/
//Tipos necesarios
  PuntoRGB=array[0..2] of byte;
  TlineaRGB=array[0..MAX_LINEA] of PuntoRGB;
  PlineaRGB=^TlineaRGB;

//OJO que:
CImagen = class(TBitmap)

//(Aplica un "blur" en dos pasadas a un bitmap de 24bits de profundidad de color)

//Esto está implementado a manera de incluir un método adicional:

procedure CImagen.Suavizar();
var i,j,k:integer;
    rgb1,rgb2,rgb3:PlineaRGB;
begin
  for j:=2 to Height-1 do
  begin
    rgb1:=ScanLine[j-2];
    rgb2:=ScanLine[j-1];
    rgb3:=ScanLine[j];
    for i:=0 to width-1 do
      for k:=0 to 2 do //colores
        rgb2[i,k]:=(rgb1[i,k]+rgb2[i,k] shl 1+rgb3[i,k]+3) shr 2;
  end;
  for j:=0 to Height-1 do
  begin
    rgb1:=ScanLine[j];
    for i:=2 to width-1 do
      for k:=0 to 2 do //colores
        rgb1[i-1,k]:=(rgb1[i-2,k]+rgb1[i-1,k] shl 1+rgb1[i,k]+3) shr 2;//interpolar
  end;
end;