The images displayed on my blog (except for one) aren't really fractals in the sense that they're not a display of a set on the complex plane that represents the solutions to an equation. The Mandelbrot Set is, along with Julia sets, and plenty more. Most of the images on my blog however, are plotted on a Cartesian plane. This lends from the fact that instead of a set of solutions to a complex equation, they are the orbit of an Iterative Function System (IFS).
More particularly, most of my research has involved - or more appropriately: revolved around - this function. The image the link points to is an orbit of a function I've dubbed the Clover Function; primarily because it resembles a four leaf clover. The function has several properties that have made it so interesting to me, and is the reason I've put so much time and effort into understanding it better. Here they are in no particular order:
- The function seems to be containable for any number of iterations in a finite area. To clarify, if the pixels of an image at 1080p resolution (1920x1080 pixels) represent a portion of the Cartesian plane where the top left of the image is the origin, the axes are oriented in such a way that down is y+ and right is x+, and the bottom right of the image corresponds to (1920,1080), any number of iterations of this function can be plotted within that portion of the plane.
- The function seems to be very self-similar. Determining whether or not the self-similarity is infinite is one of my main research objectives. A pattern is at least visually evident in each leaf of the clover, and seems to repeat itself getting smaller and smaller each time.
- Scale dependency. The portion of the function that enables it to be contained in a finite space is also the portion that makes it very difficult to scale (zoom in/out). There are two constants in the function - cX and cY - and the IFS algorithm randomly (and with equal probability) chooses which combination of addition or subtraction to use [ +cX +cY, -cX +cY, etc.] for each iteration. Different values of cX and cY determine:
- Size of the "clovers".
- Where on the plane the points are plotted to.
- Shape of the "clovers".
- Because the output relies so heavily on these two numbers, it is difficult to isolate one effect of changing them. For instance changing shape without changing size, or changing size without changing location on the plane, etc.
- Interdependent variables. The x and y values of each iteration depend on each other. That is to say, instead of y=mx+b or y = ax² + bx +c, the function follows a different form. More akin to:
x = y²/(x+2) ± cX
y = x²/(y+2) ± cY
Please note that isn't the actual function; also that the x and y output both come from initial input. Here x is computed before y, but the new value for x is not used in the computation of y. - In the previous bullet the two constants are shown in similar fashion to how they are used in the IFS. Note that there are 4 combinations of addition or subtraction of cX and cY. As it turns out the function seems to be bound by the four points (cX,cY), (-cX,cY), (-cX,-cY), and (cX, -cY). After countless times of drawing this function, points have only missed the image if cX and cY were larger than the corresponding resolution (by some multiplicative value). Of course, observation is one thing; proof is another. In the IFS, each combination of sign (+ or -) of each constant is done in a separate method, so there are 4 methods that correspond to the clover function. Each method is selected at random and the output is plotted on the image.
That's a brief overview of what has been done, but more importantly, properties that need more understanding. Working in two dimensions is excellent, because the points do not form a solid object making them terrible for translation into a three dimensional polygon. Also note that there is no Z value. Well, there wasn't. Recently, some of the limitations of the IFS algorithm in Java became somewhat overwhelming, and have begun to hinder further understanding of several properties. Translation of the core parts of the algorithm to Processing have changed that. Giving up high resolution output with some degree of color manipulation, to gain rapid translation, scaling, and even rotation! While the Java implementation is still very useful for visually studying the orbits, the ability to manipulate cX and cY along with which area is in view in real time is extremely beneficial. Also, while the output of the function remains in two dimensions, it is being plotted in 3 dimensions. This allows for moving the plane function is on forward and backward, without changing how the points are calculated; i.e.: zoom in/zoom out.
As a matter of fact, the benefits of the translations go beyond zooming and rotation, they also allow for translation!
No comments:
Post a Comment