Click here to Skip to main content
13,796,361 members
Click here to Skip to main content
Add your own
alternative version


39 bookmarked
Posted 24 Dec 2005

The Koch Curve - Snowflake!

, 24 Dec 2005
Rate this:
Please Sign up or sign in to vote.
Using the Koch curve, a fractal, to draw a snowflake.

A merry Christmas to all CPians!


This program is written in VS2005, however, it would be very easy to convert to VS2003 and .NET 1.1.

The Koch curve is a simple fractal that creates a pretty snowflake-like object. The iteration algorithm is very simple:

  1. Start with a straight line:

  2. Trisect the line into three segments:

  3. Form an equilateral triangle rising out of the middle segment:

  4. Repeat, with newly formed segment.

    If you start with an equilateral triangle instead of a line, you get the lovely image shown at the top of the article after a few iterations.

The program

The program is very simple. There are some constants that define the screen area, scaling and the offset of the initial snowflake, and the angle that we use to construct the equilateral triangle out of the middle segment:

private const int width = 400;
private const int height = 300;
private const double scale = 0.5;
private const int xoffset = width / 4;
private const int yoffset = height / 6;
private const double rangle = -60 * Math.PI / 180.0;
private const int maxFlakes=2;

While running, the program draws several snowflakes in random positions and in random colors. After a set limit (which in the demo I have set to 2), the first snowflake in the list is removed (rendering starts to really bog down if we keep all the snowflakes).


public Form1()
  rand=new Random((int)DateTime.Now.Ticks);
  FormBorderStyle = FormBorderStyle.None;
  StartPosition = FormStartPosition.CenterScreen;
  ClientSize = new Size(width, height);
  backBrush = new SolidBrush(Color.LightBlue);
  pens = new List<Pen>(new Pen[] {new Pen(Color.White), 
               new Pen(Color.Red), new Pen(Color.Green)});
  segPen = pens[0];
  windowRect = new Rectangle(0, 0, width, height);
  SetStyle(ControlStyles.DoubleBuffer | ControlStyles.UserPaint | 
                        ControlStyles.AllPaintingInWmPaint, true);
  segments = new List<Segment>();
  flakes = new List<Flake>();
  segments.Add(new Segment(0, height, width/2, 0));
  segments.Add(new Segment(width/2, 0, width, height));
  segments.Add(new Segment(width, height, 0, height));
  timer = new Timer();
  timer.Interval = 100;
  timer.Tick += new EventHandler(OnTick);

Three pens are initialized and the starting equilateral triangle is constructed. The timer event will generate the next iteration. Also, the "working" snowflake segment collection is initialized, as well as the completed snowflake collection. You'll also note the SetStyle call, which enables double buffering and owner-draw painting of the form.


During painting, both the "working" snowflake and the completed snowflakes are drawn:

protected override void OnPaint(PaintEventArgs e)
  foreach (Segment seg in segments)
    e.Graphics.DrawLine(segPen, Adjust(seg.P1), Adjust(seg.P2));

  foreach (Flake flake in flakes)

You'll note that the Adjust method, which scales and offsets the coordinates, is used so as to preserve the accuracy of the snowflake's coordinates during iteration.


When the timer event fires, the snowflake iterates to the next step, following the algorithm I described above:

void OnTick(object sender, EventArgs e)
  List<Segment> newSegments = new List<Segment>();

  foreach (Segment seg in segments)
    double length=seg.Length/3;
    double a = Math.Atan2(seg.Height, seg.Width);
    a = a + rangle;
    Point p1 = new Point(seg.P1.X + seg.Width / 3, 
                         seg.P1.Y + seg.Height / 3);
    Point p2 = new Point(seg.P1.X + seg.Width * 2 / 3, 
                         seg.P1.Y + seg.Height * 2 / 3);
    Segment cutSeg = new Segment(p1.X, p1.Y, p2.X, p2.Y);
    Point p = new Point((int)(cutSeg.P1.X + length * Math.Cos(a)), 
                        (int)(cutSeg.P1.Y + length * Math.Sin(a)));
    newSegments.Add(new Segment(seg.P1.X, seg.P1.Y, p1.X, p1.Y));
    newSegments.Add(new Segment(p1.X, p1.Y, p.X, p.Y));
    newSegments.Add(new Segment(p.X, p.Y, p2.X, p2.Y));
    newSegments.Add(new Segment(p2.X, p2.Y, seg.P2.X, seg.P2.Y));

The segment is split into three pieces, where p1 is used to construct the first third and p2 is used to construct the last third. The segment cutSeg is the middle segment, which is cut out and used to build the new equilateral triangle. The third point, p, of the triangle is determined, and the new segments are added to the collection.


if (segments[0].Length <= 1)
  foreach (Segment seg in newSegments)
  seg.P1 = Adjust(seg.P1);
  seg.P2 = Adjust(seg.P2);

  flakes.Add(new Flake(segPen, newSegments));

If the first segment's length is 1 or less, then any further iteration is pointless, so the "working" snowflake is added to the completed snowflake collection. The segment locations are scaled and offset one final time, since we don't need to work with them anymore.


if (flakes.Count == maxFlakes)

this code removes the first snowflake from the collection after a set number of snowflakes have been drawn.



    int rndX = rand.Next(width);
    int rndY = rand.Next(height/2)+height/2;
    int rndW = rand.Next(width - rndX);

    double a = rangle;
    Point p = new Point((int)(rndX + rndW * Math.Cos(a)), 
                        (int)(rndY + rndW * Math.Sin(a)));

    segments.Add(new Segment(rndX, rndY, p.X, p.Y));
    segments.Add(new Segment(p.X, p.Y, rndX + rndW, rndY));
    segments.Add(new Segment(rndX + rndW, rndY, rndX, rndY));
    segPen = pens[rand.Next(3)];
    segments = newSegments;


The working snowflake segment collection is cleared and a new pen and starting point for the next snowflake is randomly determined. At the very end of the timer, the form is invalidated so that the OnPaint is called.


The Koch curve is fun because you can do many things with it, such as creating random but interesting looking coastlines and continents. If you're ever in San Diego, I have (well, last time I looked) a permanent exhibit on fractals at the Reuben H. Fleet Science Center which illustrates this.

Further reading


This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here


About the Author

Marc Clifton
United States United States
Marc is the creator of two open source projects, MyXaml, a declarative (XML) instantiation engine and the Advanced Unit Testing framework, and Interacx, a commercial n-tier RAD application suite.  Visit his website,, where you will find many of his articles and his blog.

Marc lives in Philmont, NY.

You may also be interested in...

Comments and Discussions

GeneralHere's another cool algorithm... Pin
Michael D Bray28-Dec-05 13:34
memberMichael D Bray28-Dec-05 13:34 
GeneralRe: Here's another cool algorithm... Pin
Luc Pattyn14-Jul-07 4:27
professionalLuc Pattyn14-Jul-07 4:27 
GeneralFor those who do not have C# or VS2005 Pin
PJ Arends24-Dec-05 23:59
professionalPJ Arends24-Dec-05 23:59 
GeneralRe: For those who do not have C# or VS2005 Pin
Marc Clifton25-Dec-05 5:13
protectorMarc Clifton25-Dec-05 5:13 
GeneralRe: For those who do not have C# or VS2005 Pin
geoyar27-Dec-05 16:13
membergeoyar27-Dec-05 16:13 
GeneralJust as a side note Pin
Robert Rohde24-Dec-05 23:51
memberRobert Rohde24-Dec-05 23:51 
GeneralRe: Just as a side note Pin
Marc Clifton25-Dec-05 5:04
protectorMarc Clifton25-Dec-05 5:04 
GeneralVery cool... Pin
Ray Cassick24-Dec-05 11:24
memberRay Cassick24-Dec-05 11:24 
GeneralRe: Very cool... Pin
Marc Clifton24-Dec-05 11:59
protectorMarc Clifton24-Dec-05 11:59 
GeneralNice! Pin
Vertyg024-Dec-05 11:20
memberVertyg024-Dec-05 11:20 
GeneralRe: Nice! Pin
peterchen25-Dec-05 1:10
memberpeterchen25-Dec-05 1:10 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Cookies | Terms of Use | Mobile
Web04 | 2.8.181207.3 | Last Updated 24 Dec 2005
Article Copyright 2005 by Marc Clifton
Everything else Copyright © CodeProject, 1999-2018
Layout: fixed | fluid