Creation of a test image with 2d circular shaped objects having Gaussian brightness distribution profile

Question

I want to create a test image which consists of 2d circular shaped objects each having a Gaussian brightness distribution profile.

To make it simple objects should be the same.

I then put the objects at random positions.

In the resulting composed image I would like to prevent overlapping objects.

An alternative would also be that the brighter pixels dominate.

How could that be done?

Result:

The single object:

My code:

(*a single object*)
objectData = GaussianMatrix[20, 0];
object = Image[objectData/Max[objectData]];

(*the test image,here 400 pixels square*)
imageData = Array[0 &, {400, 400}];
image = Image[imageData];

(*some random mean positions*)
randomCoords = Array[{RandomReal[], RandomReal[]} &, 20];

(*image composition*)
ImageCompose[image, object, randomCoords*400]

Answer 1

Update:

Belisarius suggested in comments a method using image processing (i.e. GaussianFilter) to generate the image. I'd modify his approach to use RandomChoice to generate the initial spots, which seems more direct to me:

img = Image@RandomChoice[{10000, 1} -> {0, 1}, {400, 400}];
ImageAdjust@GaussianFilter[img, 15]

---

I am going to create your object as the PDF of a binormal distribution with means equal to the $(x,y)$ position of the object, and equal standard deviations (to give a circular particle image) whose values (8) have been chosen to be pleasing with an image size of 400 units (of course, adjust to taste).

Clear[object, positions, imagefunction]
SeedRandom[7]

object[px_, py_] = PDF[BinormalDistribution[{px, py}, {8, 8}, 0], {x, y}];

Now generate some random positions, apply the object function to generate those objects, then sum all those distribution PDF to obtain a parametric description of a 3D surface:

positions = RandomInteger[{1, 400}, {20, 2}];
imagefunction = Plus @@ object @@@ positions;

Finally use DensityPlot to slice that surface and obtain your image:

DensityPlot[imagefunction, {x, 1, 400}, {y, 1, 400},
  PlotPoints -> 150, ColorFunction -> GrayLevel,
  Frame -> None, PlotRange -> All
]

To get an actual image, rather than a Graphics object, use e.g. Rasterize, Export ...:

Rasterize[%]

Answer 2

One way to proceed is to make an image that contains a single white pixel at each desired center point and then to convolve the small particle with the image:

particle = Import["http://i.stack.imgur.com/gi6U1.png"];
randomCoords = Array[{RandomReal[], RandomReal[]} &, 20];
img = Image[Array[0 &, {400, 400}]];
points = ReplacePixelValue[img, randomCoords*400 -> 1];
ImageConvolve[points, particle]

Answer 3

ImageAdjustwon't work well when there are superpositions,

SeedRandom[42];
n = 400;
gf[i_Image] := GaussianFilter[i, {n/20, n/80}]
ImageAdjust [ ri= gf@RandomImage[BernoulliDistribution[50/n^2], {n, n}]]

Use Clip/Rescale instead:

resc = Max@ImageData@gf@Image@SparseArray[{n/2, n/2} -> 1, {n, n}];

Image@Clip@Rescale[ImageData@ri, {0, resc}]
(* or, mostly the same but slower*)
ImageApply[Clip@Rescale[#, {0, resc}] &, ri]

Answer 4

Here is a pedestrian way to avoid overlaps. I'll show it "by hand" although it could be automated. I believe this or something similar came up once before on this forum but I cannot seem to locate it.

The original setup is as follows.

rad = 20;
scale = 400;
objectData = GaussianMatrix[rad, 0];
object = Image[objectData/Max[objectData]];
imageData = Array[0 &, {scale, scale}];
image = Image[imageData];
SeedRandom[1111];
randomCoords = RandomReal[1, {20, 2}];
image1 = ImageCompose[image, object, randomCoords*scale]

To get something similar but without overlaps we can iteratively use Nearest. I'll show one approach although there are others. The idea is to select only points that have no neighbor too close. This is inefficient insofar as we could take one from any pair that overlap, but implementing that means in effect changing the NearestFunction in a loop.

SeedRandom[1111];
randomCoords = Array[{RandomReal[], RandomReal[]} &, 40];
nf = Nearest[randomCoords];
randomCoords2 = 
  Select[randomCoords, 
   With[{nbr = nf[#, {2, 2/Sqrt[scale]}]}, Length[nbr] == 1] &];
Length[randomCoords2]
randomCoords3 = Array[{RandomReal[], RandomReal[]} &, 30];
nf2 = Nearest[Join[randomCoords2, randomCoords3]];
randomCoords4 = 
  Select[randomCoords3, 
   With[{nbr = nf2[#, {2, 2/Sqrt[scale]}]}, Length[nbr] == 1] &];
Length[randomCoords4]

(* Out[246]= 11

Out[250]= 9 *)

We again have 20 points as luck would have it. So let's look at the placement this time.

image2 = ImageCompose[image, object, 
  Join[randomCoords2, randomCoords4]*400]