Draw a fractal curve generated by prime numbers in C#


fractal curve generated by prime numbers

This example shows how to draw a fractal curve generated by prime numbers. It’s a modification of the earlier example Draw a fractal generated by prime numbers in C#.

The basic idea is follow these rules:

  1. Start at the point (0, 0), corresponding to the prime 7.
  2. Go to the next prime.
  3. Take one of the following steps depending on the prime’s form:
    1. 5n + 1: Move up 1 pixel
    2. 5n + 2: Move right 1 pixel
    3. 5n + 3: Move down 1 pixel
    4. 5n + 4: Move left 1 pixel
  4. Repeat from step 2 until bored.

The earlier example simply plots the points. This example draws lines between the points. It scales and translates the result so it as big as possible while still fitting on the drawing surface.

The following code shows how the program draws its fractal curve.

// Draw the fractal.
private void btnDraw_Click(object sender, EventArgs e)
{
    Cursor = Cursors.WaitCursor;
    Refresh();

    // Generate the points.
    int num_points = int.Parse(txtNumPoints.Text);
    Point[] points = new Point[num_points];
    Point current_point = new Point(0, 0);
    int prime = 7;
    for (long i = 0; i < num_points; i++)
    {
        // Find the next prime.
        while (!IsPrime(prime)) prime += 2;

        // Use this prime.
        switch (prime % 5)
        {
            case 1:
                current_point.Y--;
                break;
            case 2:
                current_point.X++;
                break;
            case 3:
                current_point.Y++;
                break;
            case 4:
                current_point.X--;
                break;
        }
        points[i] = current_point;

        // Move to the next possible prime.
        prime += 2;
    }

    // Draw the points.
    const int width = 500;
    Bitmap bm = new Bitmap(width, width);
    using (Graphics gr = Graphics.FromImage(bm))
    {
        gr.Clear(Color.Black);

        // Get the largest and smallest coordinates.
        var x_query =
            from Point point in points
            select point.X;
        int[] xs = x_query.ToArray();
        int xmin = xs.Min();
        int xmax = xs.Max();
        int wid = xmax - xmin;

        var y_query =
            from Point point in points
            select point.Y;
        int[] ys = y_query.ToArray();
        int ymin = ys.Min();
        int ymax = ys.Max();
        int hgt = ymax - ymin;

        float scale = width / Math.Max(wid, hgt);

        // Scale and translate.
        gr.TranslateTransform(-xmin, -ymin);
        gr.ScaleTransform(scale, scale, MatrixOrder.Append);

        using (Pen thin_pen = new Pen(Color.Red, 0))
        {
            // Draw the lines.
            gr.DrawLines(thin_pen, points);

            // Draw the axes.
            thin_pen.Color = Color.Blue;
            gr.DrawLine(thin_pen, xmin, 0, xmax, 0);
            gr.DrawLine(thin_pen, 0, ymin, 0, ymax);
        }
    }

    picFractal.Image = bm;
    picFractal.Visible = true;

    Cursor = Cursors.Default;
}

The program creates an array of Points to hold the points it generates. Next it sets current_point = (0, 0) and sets prime = 7. It then enters a loop to generate the points.

Inside the loop that generates a point, the program enters another loop. As long as prime is not prime, the code adds 2 to it. (The value prime starts at 7, so this loop only generates odd numbers.)

When it finds a prime, the program uses the rules to update current_point. It saves the new location and continues the outer loop to generate all of the points.

After it finishes generating the points, the program draws lines connecting them. To make the drawing as large as possible, the code first uses LINQ to get the minimum and maximum X and Y coordinates for all of the points. It translates the drawing to move the smallest coordinates to the origin. It then scales the drawing to make the drawing's larger dimension (width or height) cover the drawing's width.

After building the necessary transformations, the program draws lines connecting the points and draws the X and Y axes. The code finishes by displaying the result.

Note that if you use too many values, the program must scale the results down until they're so small you don't really see more than you do with the earlier example.


Download Example   Follow me on Twitter   RSS feed




About RodStephens

Rod Stephens is a software consultant and author who has written more than 30 books and 250 magazine articles covering C#, Visual Basic, Visual Basic for Applications, Delphi, and Java.
This entry was posted in algorithms, fractals, graphics, mathematics and tagged , , , , , , , , , , , . Bookmark the permalink.

One Response to Draw a fractal curve generated by prime numbers in C#

  1. Pingback: Draw a colored fractal curve generated by prime numbers in C# -

Leave a Reply

Your email address will not be published. Required fields are marked *