Create a experiment with dots appearing random on a screen

[David McFarlane]

I recently contemplated this very problem while working on a spatial 
foraging task.  I am still a long way from implementing my planned 
solution, so I have no code to show, but allow me to sketch out my strategy.

In short, I plan to first divide the screen up into a number of 
non-overlapping zones.  If I have at least as many zones as I have 
dots, then I can put each dot into a random position within its own 
zone, and that will guarantee that no dots overlap.  Dots in adjacent 
zones might still touch each other and form "clumps", but if I wanted 
to avoid that then I would just add a limit to where each dot could 
go within its own zone.

If I make exactly as many zones as dots, then the dots will disperse 
about the entire screen with some degree of jitter between the 
dots.  If I want to allow for greater jitter across the screen, I 
could create more zones than dots.  In that case I would put the 
zones into a list, shuffle the list, then pick the first nDots zones 
for my dots, and then put each dot in a random place within its zone 
(perhaps with a limit as described above to prevent dots from 
toucing).  This would then allow some degree of clumping of dots 
across the screen.  In fact if I were serious about this I would 
parameterize it all so that I could easily reuse and control the 
procedure, something like GrowLandscape( nItems, nZones, zoneBuffer ).

Looking at this in a more theoretical and general way, we can 
separate the solution space into three domains, nZones < nDots, 
nZones = nDots, and nZones > nDots.  nZones < nDots leaves the 
possibility of dots overlapping; nZones = nDots prevents overlapping 
dots and produces the most even dispersal of dots across the screen; 
and nZones > nDots also prevents overlapping dots, while allowing for 
greater jitter overall and the possibility of some clumping.  In the 
limit, nZones = 1 is just your current situation and has the most 
problem with overlap, while nZones = nPixels prevents overlap while 
allowing for the greatest jitter and clumping.  Sor for your 
puprposes I think you want nZones somewhere between nDots and nPixels.

I hope this helps somewhat, at least I enjoyed documenting this for 
myself.  I at least would be very interested to learn what you come 
up with, so please post back.

-- David McFarlane, Professional Faultfinder


>Hi,
>
>we are trying to create an experiment in eprime where participants
>will see purple and green dots for 500 ms on a screen. Their job is to
>determine whether their was more purple or green dots presented to
>them.
>
>The dots will be various size, however, we do want the area covered
>(i.e. pixels) to be the same between the different colored dots even
>though you might see e.g. more purple dots than green. The maximum
>dots shown for each color is 15.
>
>We have tried to created the experiment for a while, however, we keep
>on running into a couple of issues.
>
>1) The dots overlap each other
>2) We have to manually make a list for each dot and then have it run
>random during the experiment, however, this is very tedious as we can
>have up to 32 dots and thus 32 list for a screen.
>
>Anyways, appreciate any help we can get.
>
>Thanks!


--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "E-Prime" group.
To post to this group, send email to e-prime at googlegroups.com
To unsubscribe from this group, send email to e-prime+unsubscribe at googlegroups.com
For more options, visit this group at http://groups.google.com/group/e-prime?hl=en
-~----------~----~----~----~------~----~------~--~---