ubikuberalles' Blog

Very cool!

 

It reminds of a program I saw on TV about fractals and the Mandelbrot set. They drew a Mandelbrot set and rotated the colors like you did, and it created the effect that it was "moving," kind of like going through a never-ending a tunnel. I was totally mesmerized.

 

Check this out; it's very similar to what you've created:

 

http://www.eddaardvark.co.uk/python_patterns/mbaindex.htm

Fractal patterns and the Mandelbrot set are something I plan to work on in the near future. I wrote a program for my Atari ST some twenty years ago and the patterns it generated were pretty cool. I started making a bunch of images with the program with the intent of creating a movie. It took at least an hour for the computer to make each frame. Unfortunately I can't find the image files or even the source code for it. This means I'll have to start all over again from scratch.

 

Currently I am reading a book on Chaos Theory and fractal patterns and it's giving me all sorts of ideas about what programs to write. I'm still working on some non-fractal patterns and so it may be a little while before I display any fractal art.

 

Stay tuned, I have more art-generating programs to show off.

Sounds cool; computer generated art has always been interesting to me, even though I'm a terrible artist, and have no interest in ever becoming an artist. But I like looking at it.

 

An interesting variation on your circle-line program would be to vary the points. The way you're implementing it now, all the intervals are equal (I assume, although you didn't show an example with a number of points not divisible by 360). There's a (semi-) famous logic puzzle that goes something like this:

 

There's a circular table with 13 chairs (I don't remember the exact number), each numbered 1-13, going clockwise (like a clock). You want to sit in the chair numbered 1. The way you decided where you will sit is by skipping every other chair. So the first time around, if you choose to start at chair 1, you can't sit in any of the even-numbered chairs. i.e.

 

1 2 3 4 5 6 7 8 9 10 11 12 13

 

Now you're on chair 13, but you still have to skip every other chair, so you cross out chair 1, bypass chair 2 (it's already gone), and now you're on chair 3. After the second iteration, it would look like this:

 

1 2 3 4 5 6 7 8 9 10 11 12 13

 

Keep repeating this process of skipping every other chair until only one chair is left (in the example I just made up, the last chair would be 11). Which chair do you start at so that chair #1 is the last chair left?

 

Obviously, the solution is irrelevant, but I was thinking what if you selected the points on the circle like that? Instead of evenly spacing them out, you choose an interval (in degrees?) that you start with, and place points like that until the entire circle is filled.

 

For example, if you choose your interval to be 7, then you'd place a point at 1, 8, 15, 22, 29, etc. until all points on the perimeter of the circle were filled (assuming each point on the perimeter of the circle was numbered 1-360). I don't know if it would make any difference, but I think each generated circle would look different depending on the interval you chose (after you added color, of course).

 

Anyway, your pictures made me think of that puzzle. I'm not sure if I related it in a coherent fashion, though...

Obviously, the solution is irrelevant, but I was thinking what if you selected the points on the circle like that? Instead of evenly spacing them out, you choose an interval (in degrees?) that you start with, and place points like that until the entire circle is filled.

 

All right, here's a puzzle for you: suppose you're going to want to place some number of points around a circle, but you don't know in advance how many. All points must be placed the same distance around the circle, starting from a certain point, and you want to maximize the distance between the two closest points.

 

If you place the points e.g. every 80 degrees, then your first few nine would be at 0, 80, 160, 240, 320, 40, 120, 200, and 280 but then you'd hit the starting point, so 80 degrees would be no good if you had more than nine points. Using 80.01 degrees instead would let you go a lot longer before you hit the same point twice, but your tenth point would be very close to the first.

 

Is there any spacing that can be chosen so that for any n, the distance between the two closest points is at least 1/2.5n times the circumference of the circle?

 

Hint: the answer is found in nature.

 

Is there any spacing that can be chosen so that for any n, the distance between the two closest points is at least 1/2.5n times the circumference of the circle?

 

Hint: the answer is found in nature.

 

Would that have any relation to the Golden Ratio?

So, my other post got me curious, so I went ahead and created a program to do whatever gibberish I said earlier. Except I'm pretty sure I made a trigonometric mistake somewhere, but I like the results, so I don't really care.

 

Here's a few examples:

 

Interval: 30

 

Interval: 15

 

Interval: 187

 

Interval: 111

 

You get the idea. If you want to play around with it, just change the interval, color and radius variables in the URL.

Here's the source code if anyone's interested: circlesource.php.

 

Edit: My error was actually a group theory error, not a trig error. Fixed version is here: circles 2. It's quite a bit slower, but the differences are pretty evident, e.g. interval 115 circles 2 and interval 115 circles.

Wow. I am loving the responses to this blog entry! You guys are giving me some great ideas for modifications to my CircleLine program. I had moved CircleLine in the "completed" folder but now it's back in the development folder and may stay there a while.

 

First of all, thanks HeckYesIDid for posting your code on the circular chairs problem. I was trying to figure out how to implement that problem in my CircleLine program but I was getting nowhere. It turns out, after examining your code, that my approach to making the lines around the circle is completely different from yours. I noticed that you found out, like I did, that mistakes can sometime yield pleasing results.

 

The way mine works is I calculate the angle between each point by dividing 360 by the number of points. I then calculate the x and y positions of the points and store them in two arrays (an X array and a Y array). Using those arrays, drawing lines between the points becomes trivial.

 

Here's a portion of the main line drawing routine showing the filling of the arrays and the drawing of the lines:

 

	' Fill the array with the points to plot
For i = 1 To NumPoints
	CurAngle = DeltaAngle * CDbl(i - 1) * conPi / 180#
	PlotX(i) = CenterX + Radius * Cos(CurAngle)
	PlotY(i) = CenterY + Radius * Sin(CurAngle)
		
	' Plot a reference dot on the circle
	frmCircleLine.Circle (PlotX(i), PlotY(i)), 50
Next i
	
' Now draw lines connecting the dots
ColorNumber = StartColor
For i = 1 To NumPoints - 1
	For j = i + 1 To NumPoints
		If NumColors > 1 Then
			frmCircleLine.ForeColor = RGB(RedPalette(ColorNumber), GreenPalette(ColorNumber), Bluepalette(ColorNumber))
		
			' Change the line color
			ColorNumber = ColorNumber + 1
			If ColorNumber > MaxColors Then
				ColorNumber = 0
			End If
		End If
		frmCircleLine.Line (PlotX(i), PlotY(i))-(PlotX(j), PlotY(j))
	Next j
Next i

 

As you can see, it doesn't matter if the number of points are evenly divisible by 360: the points will always be evenly distributed across the circle. The only real difference between even and odd number of points in the circle is that you have a black void in the center of the odd-number circle (when there are more than 30 points to plot - not so noticeable when there are less than 30 points).

 

My initial approach to the circular chair problem was to fill the PlotX and PlotY arrays by skipping each second cell until I met the end conditions (therefore the index of the array represented the angle in degrees). However, I would have had to radically change the linedrawing loops and figure out how to not plot the empty cells. I was also using radians instead of degrees, making it even more complicated. It didn't occur to me to use the modulas operator (whatever it is in Visual Basic).

 

Using random colors is a good idea. I created an array and stored a predefined palette in the array. Using random colors would give the program more variety.

 

@supercat: I have no idea what the answer is to your question. The golden ratio, like mezrabad said, would be my first guess. Mandebrot's book, The Fractal Geometry of Nature mentions all sorts of ratios (although 1.26 shows up a lot in his book).

 

BTW, if anyone is interested in the source code for any of these art programs of mine, PM me your E-mail address and I'll send you a zip of all the relevant files.

 

I have a couple other ideas for the CircleLine program. For example, instead of plotting the points on the perimeter of the circle, I could plot them in the interior. I could do this by attenuating the radius with a sine wave or other function (e^x or adding the cos and sin functions comes to mind). I'm guessing here, but the sin function will probably generate a small spiral pattern.

 

I am sometimes amazed how such simple code can generate complicated results.

@supercat: I have no idea what the answer is to your question. The golden ratio, like mezrabad said, would be my first guess. Mandebrot's book, The Fractal Geometry of Nature mentions all sorts of ratios (although 1.26 shows up a lot in his book).

 

The Golden Ratio is indeed magical in this way. Some plants' arrangements of branches tend to tend toward this golden-mean behavior, probably because it minimizes the amount of shading of the lower branches by upper ones.

Here's the main difference in my circles2.php program from circles:

 

$i = 0;
$order = 0;
while ($i != 360)
{
 $i %= 360;
 $order++;
 $i += $interval;
}
 
$i = 0;
while ($i != 360)
{
 $i %= 360;
 for ($j = 0; $j < $order; $j++)
 {
[draw the line with a random color, etc.]   
 }
 $i += $interval;
}

 

The only difference was the number of lines drawn from each point. As you can see (maybe), it depends on the order of the interval in the additive group Z[360]. To figure out the order of an element in this group, you just keep adding it to itself, until it equals 0 mod 360. I think there's an actual formula, or something for figuring that out, but I haven't taken group theory for a few years. What this also does is make all elements with equal order look the same. For example, if your interval is n, then 360-n will look exactly the same.