#code or tutorials

This is perfect in an image situation, when you only really want to plot one pixel at any particular co-ordinate. So we start with a generator_function like this:

def pixel_bin(start_x, start_y, width, border = 3):     for y in xrange(start_y + border, start_y + width - border):         for y in xrange(start_x + border, start_x + width - border:             yield (x,y)

To create a bin-object at (0,0), with 150x150 pixels you just go:

this_bin = pixel_bin(0,0,150)

All this object does is spit out the co-ordinates within the square when you ask for them, one at a time, leaving a few pixels at the edges as a border (defaults to 3px). Once all possible co-ordinates have been used, it will stop returning values, so there won't be any bugs due to a bin becoming full. There so many different ways to create a generator in python, this is a common one, some others can be prettier.*

Then you create each one of these for the bins you require, and store them in a list or dictionary (hash-table). You could put the bins in an ordered grid, or all over the place. Whatever suits you.

Next, get some cool mapping function which accepts a pixel and returns the identity of whichever bin it should go into. This identity can be in any form you like. For instance it could return a string that reads "Hue 12 Saturation 3" (the most human-readable thing I could think of. also the worst thing to program). Then you pass this identity over to the list/dictionary that accepts it, and directs you to the correct bin based on its content.

so you could kind of do this:

for pixel in image:     identity = cool_mapping_function(pixel)     x, y = bin_container[indentity].next()     output_image[x,y] = pixel

the weirdest bit of this is "x, y = bin_container[identity].next()". bin_container is a dictionary in this case, and when accessed with the identity, returns a specific generator (which is created with the pixel_bin function). Then we call the pixel_bin.next() method on the generator, which returns the next set of x,y co-ordinates.

For instance, if we had a bin in the top left at the image starting at (2, 2), the first time you call pixel_bin.next(), you get (2,2). The next time you call .next() it will return (3,2) and so on. When pixels go into bins with different identities, the other pixel_bins retain their existing state until needed, so each bin will be filled sequentially.

The advantage of this is that pixels do not have to be stored in a list when they have been processed. When there are a few million pixels in an image, this frees up plenty of memory.

* the code below produces a generator exactly like the one above, but using "constructor notation", which is great for producing a sequence without all that 1991 style indenting/nesting loops. Some people like it.