WTF is this?

The images you see on this blog are output from various Ulam spiral generators I built in Flash, Python and most recently using Arduino. Generally, each dot in an image represents a number with integer 1 at center. In addition to writing algorithms to test each number for primality within a set I have discovered that an infinite number of calculations can be performed to create new designs and animation algorithms. The simplicity and speed of these algorithms make them an ideal fit for embedded systems graphics, scientific, mathematical and artistic explorations.

Friday, October 31, 2008

Respliced Satellite Maps

Some tinkering with PIL and Google Maps produced these cartographic miscarriages:

And yes, we're still doing this with basic Ulam spiral algorithm.

Test: round( pow(sqrt(pInt)/e, 1.2) )%3==0

test: round( pow(sqrt(pInt)/e, 1.2) )%5==0

test: round( pInt/e )%3==0


Borrowing from Myka's number testing algorithm, I've introduced the x and y coordinates into the mix. The test round((pi*pX)*(pY)*pInt)%2==0
appears in Myka's Square series. Thanks for the math, mofo. Of course, the resulting imagery differs greatly. My functions seem to lack the additional voodoo required to create the interference patterns.

And then I studied the Myka algorithms a bit more carefully. Behold:

This is using round( (pi*pX)*(pY)*.0025) % 2==0, producing the same pattern as this Myka square.

But here we use 2500 unique 4x4 pixel images to iteratively construct the same pattern:

This is the core image that was used to create the above spiral:

This is not to say we simple overlay the image into the positive shape of the spiral. The core image is "ripped" into small square pieces, and a list of these images is referenced in as we step around the center point. The result is a color palette borrowed from the image.

Distilling the Lake Water

round( (pi*pX)*(pY)*(distillNumber(pInt)*.00025))%2==0

Pulling back on the stick we fly higher. This is at altitude .0000025 where round( (pi*pX)*(pY)*(distillNumber(pInt)*.0000025))%2==0

round( (pi*pX)*(pY)*(distillNumber(pInt)*.00000025))%2==0

And yet higher still. Using .000000025 is absolutely rediculous, but it works.
round( (pi*pX)*(pY)*(distillNumber(pInt)*.000000025))%2==0

It appears to be a recursive fractal image, for the same pattern is re-emerging as we go deeper into the mathematical abyss.

A curious blend of pi and e...
round( ((pi*e)*pX)*(pY)*(distillNumber(pInt)* (sin(pInt)*.000000025) ))%2==0

round( (pX*pY)* pow(sqrt(pInt)/e, 1.2)*.0000025 )%3==0

Lord have mercy.
round( (pX*pY)* pow(sqrt(pInt)/e, 1.2)*.00000025 )%2==0

round( (pX*pY)* pow(sqrt(pInt)/e, 1.2)*.000000025 )%2==0

round( (pX*pY)* pow(sqrt(pInt)/e, 1.2)*.0000000125 )%2==0

round( (pX*pY)* pow(sqrt(pInt)/pi, 1.23)*.000000125 )%5==0

The Aboriginal Series

round( (pX*pY)* pow(sqrt(pInt)/pi, 1.23456789)*.000123456789 )%5==0

round( (pX*pY)* pow(sqrt(pInt)/pi, 1.23456789)*.0000123456789 )%5==0

round( (pX*pY)* pow(sqrt(pInt)/pi, 1.23456789)*.00005 )%3==0

Colorized version:

I'm pretty sure this overall pattern is a map of the universe, reality, and everything.

round( (pX*pY)* pow( sqrt(pInt), 1.23456789)*.00005 )%3==0

No comments: