Through the Interface

Creating Fibonacci spirals in AutoCAD using F#

I recently stumbled across this post which inspired me to do something similar in AutoCAD (the fact that both posts cover Fibonacci spirals and use F# is about where the similarity ends - they do things quite differently).

Fibonacci spirals are an approximation of the golden spiral, which for old timers out there will be reminiscent of the AutoCAD R12 (it was R12, wasn’t it?) design collateral - the same as this one from AME 2.1 - which I still find cool after all these years. :-)

The first thing was to create a function that returns a portion of the Fibonacci sequence:

let fibs n =

  Seq.unfold (fun (n0, n1) -> Some(n0, (n1, n0 + n1))) (0I,1I)

  |> Seq.take n

  |> Seq.to_list

A few comments about this implementation:

• I searched online for tail-recursive Fibonacci implementations (not that we’re likely to create a stack overflow with the number of recursions we’re going to do, but I like to do things right when I can :-)
  • Tail-recursive solutions are easy if returning a specific number, but as we need to return a portion of the Fibonacci sequence things get a little more complicated
  • Here’s a quick reminder of how we can check that tail call optimization has happened, when we do choose to use tail recursion
• I ended up going for a lazily-evalulated solution, copied and modified from the Foundations of F# book by Robert Pickering
  • Unfold (OK – I admit this Wikipedia entry is beyond obscure for most of us mere mortals – this post may be of more help) applies a function to a seed value to create what may be an infinite sequence of numbers (which is precisely what the Fibonacci sequence is, of course)
  • We use the Seq data-type (essentially an IEnumerable in .NET) which is lazy
    • This means that it only actually evaluates the various items in the list as we ask for them
  • We then “take” the first n items from the list (n will be specified by the user), so only that number of items get evaluated
  • We convert the results to a list to return to the caller
• I like the elegance of this solution and it’s certainly efficient enough for our purposes

If you load this code into F# interactive and execute it against the first 20 numbers in the sequence, you get:

> fibs 20;;

val it : bigint list

= [0I; 1I; 1I; 2I; 3I; 5I; 8I; 13I; 21I; 34I; 55I; 89I; 144I; 233I; 377I; 610I;

  987I; 1597I; 2584I; 4181I]

Otherwise the below implementation should be reasonably straightforward. We define a local addSegment function which we then call on each member of the subset of the Fibonacci sequence (in reverse, as we’re drawing the curves from large to small). We use the iteri function to do this, as it provides us with a useful index into the list which then allows us to decide which of the four directions we’re facing (the orientation of the arc rotates 90 degrees each time).

Here’s the complete F# code:

#light

 

// Declare our namespace and module name

 

module Fibonacci.Spiral

 

// Import managed assemblies

 

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open System

 

// A lazy Fibonacci sequence generator

 

let fibs n =

  Seq.unfold (fun (n0, n1) -> Some(n0, (n1, n0 + n1))) (0I,1I)

  |> Seq.take n

  |> Seq.to_list

 

[<CommandMethod("fib")>]

let fibonacciSpiral() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // Ask the user how deep to go

 

  let pio =

    new PromptIntegerOptions("\nEnter number of levels: ")

  pio.AllowNone <- true

  pio.AllowZero <- false

  pio.AllowNegative <- false

  pio.DefaultValue <- 10

  pio.LowerLimit <- 1

  pio.UpperLimit <- 50

  pio.UseDefaultValue <- true

 

  let pir = ed.GetInteger(pio)

 

  if pir.Status = PromptStatus.OK then

 

    // We'll actually add one to the value provided

    // as this gives more logical results

 

    let levels = pir.Value + 1

 

    // "use" has the same effect as "using" in C#

 

    use tr =

      db.TransactionManager.StartTransaction()

 

    // Get appropriately-typed BlockTable and BTRs

 

    let bt =

      tr.GetObject

        (db.BlockTableId,OpenMode.ForRead)

      :?> BlockTable

 

    let ms =

      tr.GetObject

        (bt.[BlockTableRecord.ModelSpace],

        OpenMode.ForWrite)

      :?> BlockTableRecord

 

    // Create our polyline, set its defaults,

    // add it to the modelspace and the transaction

 

    let pl = new Polyline()

    pl.SetDatabaseDefaults()

    ms.AppendEntity(pl) |> ignore

    tr.AddNewlyCreatedDBObject(pl, true)

    pl.AddVertexAt

      (pl.NumberOfVertices, Point2d.Origin, 0.0, 0.0, 0.0)

 

    // We need a mutable start point variable for

    // each of our arcs to connect

 

    let start = ref Point3d.Origin

 

    // Add an arc segment to our polyline

 

    let addSegment i size =

 

      // i is the index in the list provided by iteri

 

      // Decide the directions of the "axes" and the arc's start

      // angle based on one of four possibilities

 

      let (xdir, ydir, startAngle) =

        match (i % 4) with

        | 0 -> (Vector3d.XAxis, Vector3d.YAxis, 0.0)

        | 1 -> (-Vector3d.YAxis, Vector3d.XAxis, Math.PI * 1.5)

        | 2 -> (-Vector3d.XAxis, -Vector3d.YAxis, Math.PI)

        | 3 -> (Vector3d.YAxis, -Vector3d.XAxis, Math.PI / 2.0)

        | _ -> failwith "Invalid modulus remainder!"

 

      // The end angle is 90 degrees from the start

 

      let endAngle = startAngle + Math.PI / 2.0

 

      // The center of the arc is bottom right-hand corner

      // of the box (direction goes along the bottom from

      // left to right, so we go "size" units along the

      // direction from the start point)

 

      let center = !start + xdir * float size

 

      // Bulge is defined as the tan of one quarter of the

      // included angle (and negative, as we're going

      // clockwise)

 

      let bulge = Math.Tan((endAngle - startAngle) / -4.0)

 

      // We need to convert our 3D start point to a 2D point

      // on the plane of the polyline

 

      let pos = (!start).Convert2d(pl.GetPlane())

 

      // Now we just add the vertex at the end and mutate our

      // start variable to contain the end of the arc

 

      pl.AddVertexAt(pl.NumberOfVertices, pos, bulge, 0.0, 0.0)

      start.contents <- center + ydir * float size

 

    // Here's where we plug it all together...

 

    // Get the first n fibonacci numbers, reverse the list and

    // call our function on each one (passing its index along,

    // too)

 

    fibs levels |> List.rev |> List.iteri addSegment

    tr.Commit()

Here’s what happens when we run the FIB command and select levels 1 to 8 (we need to call FIB eight times to do this), creating eight different Fibonacci spirals:

And here’s the result for level 50, as a comparison (although unless you zoom right in it might as well be level 20):

A simple 3D LOGO implementation inside AutoCAD using F#

I've been threatening to implement this for a few posts, now, so I decided it was finally time for me to put my money where my mouth is. :-)

This post extends the series I've been writing on turtle graphics (here's the most recent part, from which you'll find links to its predecessors). This series has been about developing a turtle graphics engine using C#, eventually extending it for 3D. The series so far has focused very much on the engine, but from very early on it was my intention to use this engine to implement a subset of the LOGO programming language within AutoCAD.

[Note: you may have noticed I've switched to all capital letters when spelling "LOGO", in this post: over the last few weeks I've seen it in many places as "LOGO" and many others as "Logo". Even on Wikipedia it varies depending on the article, so in the absence of a definitive reference I've alternated to use the one I chose not to use last time. :-)]

For the language implementation I took advantage of code posted in this article, which shows how to create a simple LOGO implementation using F#. In this post we take the language-oriented portion of the F# code, extend it to implement some additional operations (especially related to 3D) and hook it up to the core C# engine.

Why did I choose to use F# for the language module? As mentioned earlier in the series, functional programming languages are very well suited to implementing other programming languages, and F# has the additional benefit of very simple interoperability with other .NET languages (such as C#, the language we used for the engine). I'd even made the decision to use F# before finding a pre-existing LOGO implementation I could just drop into my project. :-)

The development process was actually pretty painless, all told. The result is a modeless LOGO Interpreter window hosted inside AutoCAD which remembers the position and properties of the turtle, allowing you to interactively generate 3D geometry using interpreted code. Which is, in fact, very cool - even more so than I originally expected... :-)

A couple of notes: the LOGO implementation is relatively bare-bones: for instance, while you can define functions and iterate using "repeat", I miss having a conditional operator ("if... then... else..."). But not quite enough to go ahead and implement one. For now I've focused more on getting the integration with AutoCAD working.

Before we dive into the code, here's the source project, which contains a C# module and an F# module implemented using F# 1.9.4. This should save you lots of project set-up and copy & pasting, but you will still need to build both projects to try them out.

I made some changes to the TurtleEngine to support saving the current state of the turtle to the active document's UserData property, a technique covered in this previous post. I also extended the engine to allow automatic updating of the UCS to match the current turtle position & orientation: the idea being that rather than going to the trouble of displaying a turtle (which I would probably do using the Transient Graphics API in AutoCAD 2009, if I really had to), we can simply have the UCS icon (controlled via the UCSICON command) show where it is, by changing the UCS's origin and orientation to be that of the turtle. The engine creates all geometry relative to the World Coordinate System, in any case, so changing the UCS is only going to impact additional geometry created by the user.

Here's the updated C# code for the engine:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Colors;

using System.Collections;

using System;

namespace TurtleGraphics

{

  // This class encapsulates pen

  // information and will be

  // used by our TurtleEngine

  class Pen

  {

    // Private members

    private Color m_color;

    private double m_width;

    private bool m_down;

    // Public properties

    public Color Color

    {

      get { return m_color; }

      set { m_color = value; }

    }

    public double Width

    {

      get { return m_width; }

      set { m_width = value; }

    }

    public bool Down

    {

      get { return m_down; }

      set { m_down = value; }

    }

    // Constructor

    public Pen()

    {

      m_color =

        Color.FromColorIndex(ColorMethod.ByAci, 0);

      m_width = 0.0;

      m_down = false;

    }

  }

  // The main Turtle Graphics engine

  public class TurtleEngine : IDisposable

  {

    // Constants

    const string kPenKey = "TTIF_TG_Pen";

    const string kEcsKey = "TTIF_TG_Ecs";

    // Private members

    private Transaction m_trans;

    private Polyline3d m_poly;

    private Circle m_profile;

    private Pen m_pen;

    private CoordinateSystem3d m_ecs;

    private bool m_updateGraphics;

    // Public properties

    public Point3d Position

    {

      get { return m_ecs.Origin; }

      set

      {

        m_ecs =

          new CoordinateSystem3d(

            value,

            m_ecs.Xaxis,

            m_ecs.Yaxis

          );

      }

    }

    public Vector3d Direction

    {

      get { return m_ecs.Xaxis; }

    }

    // Constructor

    public TurtleEngine(Transaction tr)

    {

      m_pen = new Pen();

      m_trans = tr;

      m_poly = null;

      m_profile = null;

      m_ecs =

        new CoordinateSystem3d(

          Point3d.Origin,

          Vector3d.XAxis,

          Vector3d.YAxis

        );

      m_updateGraphics = false;

    }

    public void Dispose()

    {

      TerminateCurrentSection();

    }

    // Public methods

    public bool LoadSettings(Document doc)

    {

      Hashtable ud = doc.UserData;

      bool foundAll = true;

      m_pen = ud[kPenKey] as Pen;

      if (m_pen == null)

      {

        foundAll = false;

        object obj = ud[kPenKey];

        if (obj == null)

        {

          m_pen = new Pen();

        }

        else

        {

          // Found something different instead

          doc.Editor.WriteMessage(

            "Found an object of type \"" +

            obj.GetType().ToString() +

            "\" instead of a Pen.");

        }

      }

      if (ud.ContainsKey(kEcsKey))

      {

        m_ecs =

        (CoordinateSystem3d)ud[kEcsKey];

      }

      else

      {

        foundAll = false;

        m_ecs =

          new CoordinateSystem3d(

            Point3d.Origin,

            Vector3d.XAxis,

            Vector3d.YAxis

          );

      }

      return foundAll;

    }

    public void SaveSettings(Document doc)

    {

      ClearSettings(doc);

      Hashtable ud = doc.UserData;

      ud.Add(kPenKey, m_pen);

      ud.Add(kEcsKey, m_ecs);

    }

    public void ClearSettings(Document doc)

    {

      Hashtable ud = doc.UserData;

      if (ud.ContainsKey(kPenKey))

        ud.Remove(kPenKey);

      if (ud.ContainsKey(kEcsKey))

        ud.Remove(kEcsKey);

    }

    public void TurtleToUcs(Document doc)

    {

      Editor ed = doc.Editor;

      Matrix3d curUcs =

        ed.CurrentUserCoordinateSystem;

      ed.CurrentUserCoordinateSystem =

        curUcs.PreMultiplyBy(

          Matrix3d.AlignCoordinateSystem(

            curUcs.CoordinateSystem3d.Origin,

            curUcs.CoordinateSystem3d.Xaxis,

            curUcs.CoordinateSystem3d.Yaxis,

            curUcs.CoordinateSystem3d.Zaxis,

            m_ecs.Origin,

            m_ecs.Xaxis,

            m_ecs.Yaxis,

            m_ecs.Zaxis

          )

        );

    }

    public void Turn(double angle)

    {

      // Rotate our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Zaxis,

          Position

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis.TransformBy(mat),

          m_ecs.Yaxis.TransformBy(mat)

        );

    }

    public void Pitch(double angle)

    {

      // Pitch in our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Yaxis,

          m_ecs.Origin

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis.TransformBy(mat),

          m_ecs.Yaxis

        );

    }

    public void Roll(double angle)

    {

      // Roll along our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Xaxis,

          m_ecs.Origin

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis,

          m_ecs.Yaxis.TransformBy(mat)

        );

    }

    public void Move(double distance)

    {

      // Move the cursor by a specified

      // distance in the direction in

      // which we're pointing

      Point3d oldPos = m_ecs.Origin;

      Point3d newPos = oldPos + m_ecs.Xaxis * distance;

      m_ecs =

        new CoordinateSystem3d(

          newPos,

          m_ecs.Xaxis,

          m_ecs.Yaxis

        );

      // If the pen is down, we draw something

      if (m_pen.Down)

        GenerateSegment(oldPos, newPos);

    }

    public void PenDown()

    {

      m_pen.Down = true;

    }

    public void PenUp()

    {

      m_pen.Down = false;

      // We'll start a new entity with the next

      // use of the pen

      TerminateCurrentSection();

    }

    public void SetPenWidth(double width)

    {

      m_pen.Width = width;

      TerminateCurrentSection();

    }

    public void SetPenColor(int idx)

    {

      // Right now we just use an ACI,

      // to make the code simpler

      Color col =

        Color.FromColorIndex(

          ColorMethod.ByAci,

          (short)idx

        );

      // If we have to change the color,

      // we'll start a new entity

      // (if the entity type we're creating

      // supports per-segment colors, we

      // don't need to do this)

      if (col != m_pen.Color)

      {

        TerminateCurrentSection();

        m_pen.Color = col;

      }

    }

    // Internal helper to generate geometry

    private void GenerateSegment(

      Point3d oldPos, Point3d newPos)

    {

      Document doc =

        Autodesk.AutoCAD.ApplicationServices.

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Autodesk.AutoCAD.ApplicationServices.

      TransactionManager tm =

        doc.TransactionManager;

      // Create the current object, if there is none

      if (m_poly == null)

      {

        BlockTable bt =

          (BlockTable)m_trans.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

        BlockTableRecord ms =

          (BlockTableRecord)m_trans.GetObject(

            bt[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite

          );

        // Create the polyline

        m_poly = new Polyline3d();

        m_poly.Color = m_pen.Color;

        // Add the polyline to the database

        ms.AppendEntity(m_poly);

        m_trans.AddNewlyCreatedDBObject(m_poly, true);

        // Add the first vertex

        PolylineVertex3d vert =

          new PolylineVertex3d(oldPos);

        m_poly.AppendVertex(vert);

        m_trans.AddNewlyCreatedDBObject(vert, true);

        m_profile =

          new Circle(oldPos, Direction, m_pen.Width);

        ms.AppendEntity(m_profile);

        m_trans.AddNewlyCreatedDBObject(m_profile, true);

        m_profile.DowngradeOpen();

      }

      // Add the new vertex

      PolylineVertex3d vert2 =

        new PolylineVertex3d(newPos);

      m_poly.AppendVertex(vert2);

      m_trans.AddNewlyCreatedDBObject(vert2, true);

      // Display the graphics, to avoid long,

      // black-box operations

      if (m_updateGraphics)

      {

        tm.QueueForGraphicsFlush();

        tm.FlushGraphics();

        ed.UpdateScreen();

      }

    }

    // Internal helper to generate 3D geometry

    private void TerminateCurrentSection()

    {

      if (m_profile != null && m_poly != null)

      {

        Document doc =

          Autodesk.AutoCAD.ApplicationServices.

          Application.DocumentManager.MdiActiveDocument;

        Database db = doc.Database;

        Editor ed = doc.Editor;

        try

        {

          // Generate a Region from our circular profile

          DBObjectCollection col =

            new DBObjectCollection();

          col.Add(m_profile);

          DBObjectCollection res =

            Region.CreateFromCurves(col);

          Region reg =

            res[0] as Region;

          if (reg != null)

          {

            BlockTable bt =

              (BlockTable)m_trans.GetObject(

                db.BlockTableId,

                OpenMode.ForRead

              );

            BlockTableRecord ms =

              (BlockTableRecord)m_trans.GetObject(

                bt[BlockTableRecord.ModelSpace],

                OpenMode.ForWrite

              );

            // Extrude our Region along the Polyline3d path

            Solid3d sol = new Solid3d();

            sol.ExtrudeAlongPath(reg, m_poly, 0.0);

            sol.Color = m_pen.Color;

            // Add the generated Solid3d to the database

            ms.AppendEntity(sol);

            m_trans.AddNewlyCreatedDBObject(sol, true);

            // Get rid of the Region, profile and path

            reg.Dispose();

            m_profile.UpgradeOpen();

            m_profile.Erase();

            m_poly.Erase();

          }

        }

        catch (System.Exception ex)

        {

          ed.WriteMessage(

            "\nException: {0}",

            ex.Message

          );

        }

      }

      m_profile = null;

      m_poly = null;

    }

  }

}

Now for the language portion. You'll notice some additional commands related to pen properties and 3D, and I've also removed the "Canvas" command, as the concept is irrelevant for our purposes. I've left much of the code as it is - there was already a graphics state (gstate) object being passed in to the various functions, so rather than change the code throughout, I updated the calling function to pass in our TurtleEngine instead: F#'s code inference makes it really simple to replace one object type with another, and have that propagate throughout the project. Which is one reason F# code is much more composable (functions can be dropped into other systems with very little need for rework) than C#, for instance.

Something I noticed about the engine, when making use of Turn(), Pitch() and Roll()... the positive/negative angle values didn't always match the directions (at least not as I expected them to). So I did a little adjustment when implementing the PitchUp, PitchDown, Left & Right instructions, negating where needed. I could have also changed the engine, but I decided to leave it as a legacy implementation quirk. :-)

Here's the F# code for the language module... my apologies for the lack of comments: as I picked up someone else's code, I haven't gone through and documented what is happening (the original article helps understand this).

#light

module AutoLogo

#I @"..\bin"

#r "TurtleGraphics.dll"

#nowarn "57"

#nowarn "191"

open TurtleGraphics

open System.IO

open Printf

open String

open System.Collections.Generic

type num = float

type source =

  {

      reader : IEnumerator<token>

      pos : pos

  }

and ppos =

  {

      mutable x' : int

      mutable y' : int

  }

and pos =

  {

      x : int

      y : int

  }

and token =

| WORD of string * pos 

| VAR of string * pos

| NUMBER of num * pos

| LBRACK of pos

| RBRACK of pos

| HOLE of pos

with

  member self.IsRBrack =

      match self with

      | RBRACK _ -> true | _ -> false

end

type instr =

| Hole of pos

| Number of num * pos

| Var of string * pos

| List of instr list * pos

| Binop of (num -> num -> num) * instr * instr * pos

| Unop of (num -> num) * instr * pos

| Left of instr * pos

| Right of instr * pos

| RollLeft of instr * pos

| RollRight of instr * pos

| PitchUp of instr * pos

| PitchDown of instr * pos

| Forward of instr * pos

| PenWidth of instr * pos

| PenColor of instr * pos

| PenUp of pos

| PenDown of pos

| Repeat of instr * instr * pos

| To of string * string list * instr * pos

| FunCall of string * instr list * pos

with

  member self.Pos =

      match self with

      | Var (_, pos) | List (_, pos)

      | Hole pos | Number (_, pos)

      | Binop (_, _, _, pos) | Unop (_, _, pos)

      | Left (_, pos) | Right (_, pos)

      | RollLeft (_, pos) | RollRight (_, pos)

      | PitchUp (_, pos) | PitchDown (_, pos)

      | Forward (_, pos)

      | PenWidth (_, pos) | PenColor (_, pos)

      | PenUp pos | PenDown pos

      | Repeat (_, _, pos) | To (_, _, _, pos)

      | FunCall (_, _, pos) ->

          pos

end

type state =

  {

    funs : Map<string, string list * instr>

    vars : Map<string, float>

  } with

  static member Default =

    {

      funs = Map.Empty()

      vars = Map.Empty()

    }

end

let isEof (stream: #StringReader) = stream.Peek() = -1

let rec neq_peek allowEof (stream: #StringReader) =

  function

    | [] ->

      if allowEof then stream.Peek() <> -1 else true

    | a :: b ->

      stream.Peek() <> Char.code a &&

      neq_peek allowEof stream b

let rec eq_peek (stream: #StringReader) =

  function

    | [] ->

      stream.Peek() <> -1

    | [ a ] ->

      stream.Peek() = Char.code a &&

      stream.Peek() <> -1

    | a :: b :: rest ->

      stream.Peek() = Char.code a ||

      eq_peek stream (b :: rest)

let eatWS ((stream: #StringReader), pos) =

  while (eq_peek stream [' '; '\n'; '\t']) do

    let x, y =

      if stream.Peek()=10 then

        1, (!pos).y'+1

      else

        (!pos).x'+1, (!pos).y'

    stream.Read() |> ignore

    (!pos).x' <- x

    (!pos).y' <- y

let readWord (((stream: #StringReader), pos) as source) =

  let res, seps = ref "", [' '; ']'; '['; '?'; '\n'; '\t']

  eatWS source

  if not (neq_peek true stream []) then

    failwith "readWord"

  while (neq_peek true stream seps) do

    res := !res ^ (String.of_char (Char.chr (stream.Peek())))

    (!pos).x' <- (!pos).x' + 1

    stream.Read() |> ignore

  !res

exception Eof

let GenerateTokenStream s =

  let pos_of_ppos ({ x'=x; y'=y }: ppos) = { x=x; y=y }

  let reader =

    Seq.generate

      (fun () -> new StringReader(s), ref { x'=1; y'=1 })

      (fun ((stream, pos) as source) ->

        let rec fetch stream =

          eatWS source

          if eq_peek stream [':'] then

            let w = readWord source

            VAR (w, pos_of_ppos !pos)

          elif eq_peek stream ['['] then

            stream.Read() |> ignore

            LBRACK (pos_of_ppos !pos)

          elif eq_peek stream [']'] then

            stream.Read() |> ignore

            RBRACK (pos_of_ppos !pos)

          elif eq_peek stream ['?'] then

            stream.Read() |> ignore

            HOLE (pos_of_ppos !pos)

          elif isEof stream then

            raise Eof

          else

            let w = readWord source

            try NUMBER (float w, (pos_of_ppos !pos)) with

              _ -> WORD (w, pos_of_ppos !pos)

        try Some (fetch stream) with Eof -> None)

      (fun (stream, _) -> stream.Dispose())

  reader.GetEnumerator()

exception VarNotFound of string * pos

exception FunNotFound of string * pos

exception NoCanvas of pos

exception InvalidFunName of pos

exception InvalidParam of pos

exception UnexpectedRBrack of pos

exception UnexpectedEof

exception NumberExpected of pos

exception UnexpectedHole of pos

let find_var state pos v =

  try state.vars.[v]

  with _ -> raise (VarNotFound (v,pos))

let find_fun state pos f =

  try state.funs.[f]

  with _ -> raise (FunNotFound (f,pos))

let add_var state v va =

  { state with vars=state.vars.Add (v, va) }

let add_fun state f va =

  { state with funs=state.funs.Add (f, va) }

let ParseTokenStream state stScoping (en: IEnumerator<token>) =

  en.Reset()

  let rec parse_until state check en f =

    let state', e = parse state check true en

    let state', res = ref state', ref [ e ]

    while (f state en) do

      let state'', res' = parse !state' check false en

      res := res' :: !res

      state' := state''

    !state', List.rev !res

  and parse state check shouldMove (en: IEnumerator<token>) =

    let get1 state check en = snd (parse state check true en)

    let get2 state check en =

      let _, e1 = parse state check true en

      let _, e2 = parse state check true en

      e1, e2

    let funname_of =

      function

        | WORD (s, pos) -> s

        | VAR (_, pos) | NUMBER (_, pos) | LBRACK pos

        | RBRACK pos | HOLE pos ->

            raise (InvalidFunName pos)

    let rec params_of = function

      | Var (s, _) -> [ s ]

      | List (l, _) ->

        List.fold_left (fun lst e -> lst @ params_of e) [] l

      | instr ->

        raise (InvalidParam instr.Pos)

    let eq_string1 s s1 =

      String.lowercase s =

        String.lowercase s1

    let eq_string2 s s1 s2 =

      let s' = String.lowercase s

      s' = String.lowercase s1 || s' = String.lowercase s2

    if shouldMove && en.MoveNext() || not shouldMove then

      match en.Current with

        | WORD (s, pos) when eq_string2 s "lt" "left" ->

            let _, e = parse state check true en

            state, Left (e, pos)

        | WORD (s, pos) when eq_string2 s "rt" "right" ->

            let _, e = parse state check true en

            state, Right (e, pos)

        | WORD (s, pos) when eq_string2 s "rl" "rollleft" ->

            let _, e = parse state check true en

            state, RollLeft (e, pos)

        | WORD (s, pos) when eq_string2 s "rr" "rollright" ->

            let _, e = parse state check true en

            state, RollRight (e, pos)

        | WORD (s, pos) when eq_string2 s "pu" "pitchup" ->

            let _, e = parse state check true en

            state, PitchUp (e, pos)

        | WORD (s, pos) when eq_string2 s "pd" "pitchdown" ->

            let _, e = parse state check true en

            state, PitchDown (e, pos)

        | WORD (s, pos) when eq_string2 s "fd" "forward" ->

            let _, e = parse state check true en

            state, Forward (e, pos)

        | WORD (s, pos) when eq_string1 s "penwidth" ->

            let _, e = parse state check true en

            state, PenWidth (e, pos)

        | WORD (s, pos) when eq_string1 s "pencolor" ->

            let _, e = parse state check true en

            state, PenColor (e, pos)

        | WORD (s, pos) when eq_string1 s "penup" ->

            state, PenUp pos

        | WORD (s, pos) when eq_string1 s "pendown" ->

            state, PenDown pos

        | WORD (s, pos) when eq_string1 s "repeat" ->

            let _, e1 = parse state check true en

            let state' = add_var state ":repcount" 1.0

            let _, e2 = parse state' check true en

            state, Repeat (e1, e2, pos)

        | WORD (s, pos) when eq_string2 s "+" "sum" ->

            let e1, e2 = get2 state check en

            state, Binop ((+), e1, e2, pos)

        | WORD (s, pos) when eq_string2 s "-" "minus" ->

            let e1, e2 = get2 state check en

            state, Binop ((-), e1, e2, pos)

        | WORD (s, pos) when eq_string2 s "*" "times" ->

            let e1, e2 = get2 state check en

            state, Binop (( * ), e1, e2, pos)

        | WORD (s, pos) when eq_string2 s "/" "divide" ->

            let e1, e2 = get2 state check en

            state, Binop ((/), e1, e2, pos)

        | WORD (s, pos) when eq_string1 s "min" ->

            let e1, e2 = get2 state check en

            state, Binop (min, e1, e2, pos)

        | WORD (s, pos) when eq_string1 s "max" ->

            let e1, e2 = get2 state check en

            state, Binop (max, e1, e2, pos)

        | WORD (s, pos) when eq_string1 s "sin" ->

            let e = get1 state check en

            state, Unop (sin, e, pos)

        | WORD (s, pos) when eq_string1 s "cos" ->

            let e = get1 state check en

            state, Unop (cos, e, pos)

        | WORD (s, pos) when eq_string1 s "tan" ->

            let e = get1 state check en

            state, Unop (tan, e, pos)

        | WORD (s, pos) when eq_string1 s "pi" ->

            state, Number (System.Math.PI, pos)

        | WORD (s, pos) when eq_string1 s "repcount" ->

            state, Var (":repcount", pos)

        | WORD (s, pos) when String.lowercase s = "to" ->

            let f =

              if en.MoveNext() then

                funname_of en.Current

              else

                raise UnexpectedEof

            // Don't check formal parameters

            let _, pars = parse state false true en

            let pars' = params_of pars

            // Add formal parameters to the current state

            let state' = List.fold_left (fun state p ->

              add_var state p 0.0) state pars'

            // Add dummy reference to self

            // to allow recursive calls

            let state' = add_fun state' f (pars', Hole pos)

            let _, e = parse state' check true en

            let state'' = add_fun state f (pars', e)

            state'', To (f, pars', e, pos)

        | WORD (s, pos) ->

            let pars, _ = find_fun state pos s

            let args =

              List.fold_left

                (fun args _ ->

                  let _, e = parse state check true en

                  e :: args)

                [] pars

            state, FunCall (s, List.rev args, pos)

        | NUMBER (i, pos) ->

            state, Number (i, pos)

        | VAR (v, pos) ->

            if check then find_var state pos v |> ignore

            state, Var (v, pos)

        | HOLE pos ->

            state, Hole pos

        | LBRACK pos ->

            let _, exps =

              parse_until state check en

              (fun state (en: IEnumerator<token>) ->

                  en.MoveNext() && not en.Current.IsRBrack)

            state, List (exps, pos)

        | RBRACK pos ->

            raise (UnexpectedRBrack pos)

    else

      raise UnexpectedEof

  let _, exps =

    parse_until state stScoping en

      (fun state en -> en.MoveNext())

  exps

let rec eval (state: state) (gstate : TurtleEngine) instr =

  let rec eval2 state gstate e1 e2 =

    let state', gstate', n1 = eval1 state gstate e1

    let state'', gstate'', n2 = eval1 state' gstate' e2

    state'', gstate'', n1, n2

  and eval1 state gstate (e: instr) =

    let state', gstate', e' = eval state gstate e

    let n = num_of_value e.Pos e'

    state', gstate', n

  and num_of_value pos = function

    | Some i -> i | _ -> raise (NumberExpected pos)

  let forward state (gstate : TurtleEngine) pos d =

    gstate.Move(d)

    state, gstate, None

  match instr with

    | Binop (f, e1, e2, _) ->

        let _, gstate', n1, n2 = eval2 state gstate e1 e2

        state, gstate', Some (f n1 n2)

    | Unop (f, e, _) ->

        let _, gstate', n = eval1 state gstate e

        state, gstate', Some (f n)

    | Left (e, _) ->

        let _, gstate', i = eval1 state gstate e

        gstate'.Turn(i * System.Math.PI / 180.0)

        state, gstate', None

    | Right (e, _) ->

        let _, gstate', i = eval1 state gstate e

        gstate'.Turn(i * System.Math.PI / -180.0)

        state, gstate', None

    | RollLeft (e, _) ->

        let _, gstate', i = eval1 state gstate e

        gstate'.Roll(i * System.Math.PI / -180.0)

        state, gstate', None

    | RollRight (e, _) ->

        let _, gstate', i = eval1 state gstate e

        gstate'.Roll(i * System.Math.PI / 180.0)

        state, gstate', None

    | PitchUp (e, _) ->

        let _, gstate', i = eval1 state gstate e

        gstate'.Pitch(i * System.Math.PI / -180.0)

        state, gstate', None

    | PitchDown (e, _) ->

        let _, gstate', i = eval1 state gstate e

        gstate'.Pitch(i * System.Math.PI / 180.0)

        state, gstate', None

    | Forward (e, pos) ->

        let _, gstate', i = eval1 state gstate e

        forward state gstate' pos i

    | PenWidth (e, pos) ->

        let _, gstate', i = eval1 state gstate e

        gstate'.SetPenWidth (i / 2.0)

        state, gstate', None

    | PenColor (e, pos) ->

        let _, gstate', i = eval1 state gstate e

        gstate'.SetPenColor (int.of_float i)

        state, gstate', None

    | PenUp _ ->

        gstate.PenUp()

        state, gstate, None

    | PenDown _ ->

        gstate.PenDown()

        state, gstate, None

    | Number (n, _) ->

        state, gstate, Some n

    | Var (s, pos) ->

        let n = find_var state pos s

        state, gstate, Some n

    | FunCall (f, args, pos) ->

        let pars, body = find_fun state pos f

        let state', gstate' =

          List.fold_left2

            (fun (state, gstate) p arg ->

              let _, gstate', i =

                eval1 state gstate arg

              add_var state p i, gstate')

            (state, gstate) pars args

        let _, gstate'', res = eval state' gstate' body

        state, gstate'', res

    | Hole pos ->

        raise (UnexpectedHole pos)

    | List (lst, _) ->

        let _, gstate', res =

          List.fold_left (fun (state, gstate, res) e ->

            eval state gstate e) (state, gstate, None) lst

        state, gstate', res

    | Repeat (num, e, pos) ->

        let _, gstate', i = eval1 state gstate num

        Seq.fold (fun (state, gstate, _) j ->

          let state' = add_var state ":repcount" j

          eval state' gstate e) (state, gstate', None) { 1.0 .. i }

    | To (f, par, e, pos) ->

        let state' = add_fun state f (par, e)

        state', gstate, None

let eval_list (state: state) gstate =

  List.fold_left (fun (state, gstate, res) e ->

    eval state gstate e) (state, gstate, None)

Now for the client module. I decided to implement our user-interface via a PaletteSet, with the Source editor living on one Palette (hosting a RichTextBox control), with the various execution options living on another. I had some fun with the embedded RichTextBox: it seems AutoCAD's PaletteSet eats linefeed characters, so they don't get passed through to the active, hosted control. I looked at various ways to get around this - the most promising of which was to add a message hook at the system level, which then switches the message to something that will pass through the PaletteSet's defenses successfully for later re-mapping - but ended up with the very simple (and still reasonably pragmatic) solution of checking for semi-colons entered at the keyboard and inserting linefeeds at that point. So for all intents and purposes the semi-colon key has been remapped to work like Enter when entering code in the Source tab. Which is just fine for those of us who are hardcore C/C#/C++ coders, but less intuitive for those of us working primarily with VB. :-)

While this approach is acceptable in this application, it may not be in your own: please let me know if this is a significant problem for you and I will pass the information on to our Engineering team.

Here's the F# code for the client module:

#light

#I @"C:\Program Files\Autodesk\AutoCAD 2009"

#r "acdbmgd.dll"

#r "acmgd.dll"

#I @"..\bin"

#r "TurtleGraphics.dll"

open TurtleGraphics

open AutoLogo

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.Geometry

open Autodesk.AutoCAD.Windows

open System.Windows.Forms

open System.Drawing

open System

// Some error-handling helpers

let error {x=x; y=y} msg =

  MessageBox.Show

    (sprintf "Error at %d:%d\n%s" y x msg)

      |> ignore

let error_no_pos msg =

  MessageBox.Show

    (sprintf "Error: %s" msg)

      |> ignore

// Our code editor control

let memo =

  new RichTextBox(Dock = DockStyle.Fill)

// A tooltip explaining what to do with the window

let tt =

  new ToolTip()

tt.SetToolTip

  (memo,

  "Enter LOGO code, use semi-colons (;) instead of Enter" +

  "\n\npendown - put the pen down" +

  "\npenup - put the pen up" +

  "\npencolor i - set the color of the pen to index i" +

  "\npenwidth d - set the width of the pen to double d" +

  "\nfd d - forward distance d" +

  "\nrt a - turn right through angle a" +

  "\nlt a - turn left through angle a" +

  "\npu a - pitch up through angle a" +

  "\npd a - pitch down through angle a" +

  "\nrr a - roll right through angle a" +

  "\nrl a - roll left through angle a")

// Translate the semi-colon character into a linefeed

memo.KeyPress.Add(fun (ea : KeyPressEventArgs) ->

  if ea.KeyChar = ';' then

  memo.SelectedText <- "\n"

  ea.Handled <- true)

// Our various option checkboxes

let clrSrc =

  new CheckBox

    (Text = "Clear source after execution",

    Width = 250,

    Location = new Point(10,40),

    Checked = false)

let keepInfo =

  new CheckBox

    (Text = "Keep turtle information",

    Width = 250,

    Location = new Point(10,80),

    Checked = true)

let changeUcs =

  new CheckBox

    (Text = "Update UCS to reflect turtle position",

    Width = 250,

    Location = new Point(10,120),

    Checked = false)

keepInfo.Click.Add (fun _ ->

  changeUcs.Enabled <- keepInfo.Checked)

// Our Execute button

let run =

  new Button

    (Text = "Execute",

    Width = 100,

    Height = 30,

    Location = new Point(50,180))

// The code behind the execute button

run.Click.Add (fun _ ->

  try

    let doc =

      Application.DocumentManager.MdiActiveDocument

    // Remember to lock the document, as it's

    //  a modeless dialog

    use lock = doc.LockDocument()

    use tr =

      doc.TransactionManager.StartTransaction()

    let te = new TurtleEngine(tr)

    // If we don't load valid settings, make sure

    // there's a pen width and the pen is down

    // (this just simplifies the client code)

    if keepInfo.Checked then

      if te.LoadSettings(doc) <> true then

        te.SetPenWidth(1.0)

        te.PenDown()

    else

      te.SetPenWidth(1.0)

      te.PenDown()

    // Parse and evaluate our source

    let source =

      GenerateTokenStream memo.Text

    let e =

      ParseTokenStream state.Default true source

    let _, _, res = eval_list state.Default te e

    // Save turtle settings, if appropriate

    if keepInfo.Checked then

      if changeUcs.Checked then

        te.TurtleToUcs(doc)

      te.SaveSettings(doc)

    else

      te.ClearSettings(doc)

    // Finish up

    te.Dispose()

    tr.Commit()

    doc.Editor.UpdateScreen()

    match res with

      | None -> ()

      | Some i ->

          MessageBox.Show

            (sprintf "Exit value=%f" i) |> ignore

    // Clear the source window, if that option was selected

    if clrSrc.Checked then

      memo.Clear()

  with

    | VarNotFound (v, pos) ->

        error pos (sprintf "Unbound variable '%s'" v)

    | FunNotFound (f, pos) ->

        error pos (sprintf "Unbound function '%s'" f)

    | NoCanvas pos ->

        error pos "No canvas available to draw on"

    | InvalidFunName pos ->

        error pos "Invalid function"

    | InvalidParam pos ->

        error pos "Invalid parameter"

    | UnexpectedRBrack pos ->

        error pos "Unexpected ]"

    | UnexpectedEof ->

        error_no_pos "Unexpected eof"

    | NumberExpected pos ->

        error pos "Number expected"

    | UnexpectedHole pos ->

        error pos "[internal] Uninstantiated hole")

// Create a group box for our execution tab

let grp =

  new GroupBox(Text = "Execution Options")

grp.Controls.Add(clrSrc)

grp.Controls.Add(keepInfo)

grp.Controls.Add(changeUcs)

grp.Controls.Add(run)

// Create the palette set and set its properties

let ps =

  new PaletteSet

    ("LOGO Interpreter",

    new Guid("153C43BD-7AB9-489E-B674-175C8679812A"))

ps.Style <-

  PaletteSetStyles.ShowPropertiesMenu |||

  PaletteSetStyles.ShowAutoHideButton |||

  PaletteSetStyles.ShowCloseButton

// Make it half-transparent (or is that half-opaque? :-)

// and set its size and dockability

ps.EnableTransparency(true) |> ignore

ps.Opacity <- 50

ps.MinimumSize <- new Size(240,240)

ps.Size <- new Size(250,550)

ps.DockEnabled <-

  DockSides.Left |||

  DockSides.Right

// Add our two palettes to the set

ps.Add("Source", memo) |> ignore

ps.Add("Execution", grp) |> ignore

// Finally we define a command that simply shows

// the palette (rather than multi-instancing it)

[<CommandMethod("LOGO")>]

let startLogo() =

  ps.Activate(0) // Displays the source tab

  ps.Visible <- true

To give this a try, NETLOAD the two DLLs created by the above code (TurtleGraphics.dll and Logo.dll - it shouldn't matter in which order, as long as you load them both) and run the LOGO command. Here's the palette that gets displayed, showing here some simple LOGO source code:

Here's the LOGO code itself, to make it simpler for you to copy & paste into the Source window (which also bypasses the linefeed problem, incidentally):

to spring :x [

  pencolor :x

  repeat 50 [

      fd 1

      rt 10

      pu 10

      rr 10

  ]

]

penwidth 3

pendown

repeat 10 [spring repcount]

When executed it should create a "spring" with sections of different colours:

You can see the UCS icon is pointing in the direction the turtle will move in next. Try typing some simple instructions into the Source window, and then executing them repeatedly.

Turtle fractals in AutoCAD using .NET - Part 6

What, yet another part? The series that just goes on and on... :-)

To catch up, here are parts 1, 2, 3, 4 and 5, and the original post.

This post looks at more organic forms, once again, but this time in 3D. I had lots of fun with this one: I took the principle shown in Part 2, where we looked at adding random factors to fractal patterns when creating 2D trees and extended it to work with the 3D version of the TurtleEngine. The principle is the same, we're just creating three branches at relatively evenly spaced angles from each trunk (or senior branch). To add a little colour we draw "leaves" at the end (really just green cylinders, but they look good enough from a distance :-).

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Colors;

using System;

namespace TurtleGraphics

{

  // This class encapsulates pen

  // information and will be

  // used by our TurtleEngine

  class Pen

  {

    // Private members

    private Color m_color;

    private double m_width;

    private bool m_down;

    // Public properties

    public Color Color

    {

      get { return m_color; }

      set { m_color = value; }

    }

    public double Width

    {

      get { return m_width; }

      set { m_width = value; }

    }

    public bool Down

    {

      get { return m_down; }

      set { m_down = value; }

    }

    // Constructor

    public Pen()

    {

      m_color =

        Color.FromColorIndex(ColorMethod.ByAci, 0);

      m_width = 0.0;

      m_down = false;

    }

  }

  // The main Turtle Graphics engine

  class TurtleEngine : IDisposable

  {

    // Private members

    private Transaction m_trans;

    private Polyline3d m_poly;

    private Circle m_profile;

    private Pen m_pen;

    private CoordinateSystem3d m_ecs;

    private bool m_updateGraphics;

    // Public properties

    public Point3d Position

    {

      get { return m_ecs.Origin; }

      set {

        m_ecs =

          new CoordinateSystem3d(

            value,

            m_ecs.Xaxis,

            m_ecs.Yaxis

          );

      }

    }

    public Vector3d Direction

    {

      get { return m_ecs.Xaxis; }

    }

    // Constructor

    public TurtleEngine(Transaction tr)

    {

      m_pen = new Pen();

      m_trans = tr;

      m_poly = null;

      m_profile = null;

      m_ecs =

        new CoordinateSystem3d(

          Point3d.Origin,

          Vector3d.XAxis,

          Vector3d.YAxis

        );

      m_updateGraphics = false;

    }

    public void Dispose()

    {

      TerminateCurrentSection();

    }

    // Public methods

    public void Turn(double angle)

    {

      // Rotate our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Zaxis,

          Position

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis.TransformBy(mat),

          m_ecs.Yaxis.TransformBy(mat)

        );

    }

    public void Pitch(double angle)

    {

      // Pitch in our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Yaxis,

          m_ecs.Origin

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis.TransformBy(mat),

          m_ecs.Yaxis

        );

    }

    public void Roll(double angle)

    {

      // Roll along our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Xaxis,

          m_ecs.Origin

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis,

          m_ecs.Yaxis.TransformBy(mat)

        );

    }

    public void Move(double distance)

    {

      // Move the cursor by a specified

      // distance in the direction in

      // which we're pointing

      Point3d oldPos = m_ecs.Origin;

      Point3d newPos = oldPos + m_ecs.Xaxis * distance;

      m_ecs =

        new CoordinateSystem3d(

          newPos,

          m_ecs.Xaxis,

          m_ecs.Yaxis

        );

      // If the pen is down, we draw something

      if (m_pen.Down)

        GenerateSegment(oldPos, newPos);

    }

    public void PenDown()

    {

      m_pen.Down = true;

    }

    public void PenUp()

    {

      m_pen.Down = false;

      // We'll start a new entity with the next

      // use of the pen

      TerminateCurrentSection();

    }

    public void SetPenWidth(double width)

    {

      m_pen.Width = width;

      TerminateCurrentSection();

    }

    public void SetPenColor(int idx)

    {

      // Right now we just use an ACI,

      // to make the code simpler

      Color col =

        Color.FromColorIndex(

          ColorMethod.ByAci,

          (short)idx

        );

      // If we have to change the color,

      // we'll start a new entity

      // (if the entity type we're creating

      // supports per-segment colors, we

      // don't need to do this)

      if (col != m_pen.Color)

      {

        TerminateCurrentSection();

        m_pen.Color = col;

      }

    }

    // Internal helper to generate geometry

    private void GenerateSegment(

      Point3d oldPos, Point3d newPos)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Autodesk.AutoCAD.ApplicationServices.

      TransactionManager tm =

        doc.TransactionManager;

      // Create the current object, if there is none

      if (m_poly == null)

      {

        BlockTable bt =

          (BlockTable)m_trans.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

        BlockTableRecord ms =

          (BlockTableRecord)m_trans.GetObject(

            bt[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite

          );

        // Create the polyline

        m_poly = new Polyline3d();

        m_poly.Color = m_pen.Color;

        // Add the polyline to the database

        ms.AppendEntity(m_poly);

        m_trans.AddNewlyCreatedDBObject(m_poly, true);

        // Add the first vertex

        PolylineVertex3d vert =

          new PolylineVertex3d(oldPos);

        m_poly.AppendVertex(vert);

        m_trans.AddNewlyCreatedDBObject(vert, true);

        m_profile =

          new Circle(oldPos, Direction, m_pen.Width);

        ms.AppendEntity(m_profile);

        m_trans.AddNewlyCreatedDBObject(m_profile, true);

        m_profile.DowngradeOpen();

      }

      // Add the new vertex

      PolylineVertex3d vert2 =

        new PolylineVertex3d(newPos);

      m_poly.AppendVertex(vert2);

      m_trans.AddNewlyCreatedDBObject(vert2, true);

      // Display the graphics, to avoid long,

      // black-box operations

      if (m_updateGraphics)

      {

        tm.QueueForGraphicsFlush();

        tm.FlushGraphics();

        ed.UpdateScreen();

      }

    }

    // Internal helper to generate 3D geometry

    private void TerminateCurrentSection()

    {

      if (m_profile != null && m_poly != null)

      {

        Document doc =

          Application.DocumentManager.MdiActiveDocument;

        Database db = doc.Database;

        Editor ed = doc.Editor;

        try

        {

          // Generate a Region from our circular profile

          DBObjectCollection col =

            new DBObjectCollection();

          col.Add(m_profile);

          DBObjectCollection res =

            Region.CreateFromCurves(col);

          Region reg =

            res[0] as Region;

          if (reg != null)

          {

            BlockTable bt =

              (BlockTable)m_trans.GetObject(

                db.BlockTableId,

                OpenMode.ForRead

              );

            BlockTableRecord ms =

              (BlockTableRecord)m_trans.GetObject(

                bt[BlockTableRecord.ModelSpace],

                OpenMode.ForWrite

              );

            // Extrude our Region along the Polyline3d path

            Solid3d sol = new Solid3d();

            sol.ExtrudeAlongPath(reg, m_poly, 0.0);

            sol.Color = m_pen.Color;

            // Add the generated Solid3d to the database

            ms.AppendEntity(sol);

            m_trans.AddNewlyCreatedDBObject(sol, true);

            // Get rid of the Region, profile and path

            reg.Dispose();

            m_profile.UpgradeOpen();

            m_profile.Erase();

            m_poly.Erase();

          }

        }

        catch (System.Exception ex)

        {

          ed.WriteMessage(

            "\nException: {0}",

            ex.Message

          );

        }

      }

      m_profile = null;

      m_poly = null;

    }

  }

  public class Commands

  {

    static public bool GetTreeInfo(

      out Point3d position,

      out double treeLength,

      out int variability

    )

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      treeLength = 0;

      position = Point3d.Origin;

      variability = 0;

      PromptPointOptions ppo =

        new PromptPointOptions(

          "\nSelect base point of tree: "

        );

      PromptPointResult ppr =

        ed.GetPoint(ppo);

      if (ppr.Status != PromptStatus.OK)

        return false;

      position = ppr.Value;

      PromptDoubleOptions pdo =

        new PromptDoubleOptions(

          "\nEnter tree length <100>: "

        );

      pdo.AllowNone = true;

      PromptDoubleResult pdr =

        ed.GetDouble(pdo);

      if (pdr.Status != PromptStatus.None &&

          pdr.Status != PromptStatus.OK)

        return false;

      if (pdr.Status == PromptStatus.OK)

        treeLength = pdr.Value;

      else

        treeLength = 100;

      PromptIntegerOptions pio =

        new PromptIntegerOptions(

          "\nEnter variability percentage <20>: "

        );

      pio.AllowNone = true;

      PromptIntegerResult pir =

        ed.GetInteger(pio);

      if (pir.Status != PromptStatus.None &&

          pir.Status != PromptStatus.OK)

        return false;

      if (pir.Status == PromptStatus.OK)

        variability = pir.Value;

      else

        variability = 20;

      return true;

    }

    static void Random3DTree(

      TurtleEngine te,

      double distance,

      int variability

    )

    {

      // Some constants

      const double kLeafSize = 3.0;

      const double kBasePitch = Math.PI / 4;

      const double kBaseRoll = 2 * Math.PI / 3;

      const double kBranchFactor = 0.6;

      const double kBranchWidth = 0.05;

      const int kWoodColor = 24;

      const int kLeafColor = 3;

      // Under a certain size, we draw a leaf

      if (distance < kLeafSize)

      {

        // Draw a leaf-like cylinder

        te.SetPenColor(kLeafColor);

        te.PenDown();

        te.Move(kLeafSize);

        te.PenUp();

        te.Move(-kLeafSize);

        return;

      }

      // Generate 7 random factors, each on the same basis:

      //  a base amount = 100 - half the variability

      //  + a random amount from 0 to the variability

      // So a variability of 20 results in 90 to 110 (0.9-1.1)

      Random rnd = new Random();

      int basic = 100 - (variability / 2);

      int num = rnd.Next(variability);

      double factor1 = (basic + num) / 100.0;

      num = rnd.Next(variability);

      double factor2 = (basic + num) / 100.0;

      num = rnd.Next(variability);

      double factor3 = (basic + num) / 100.0;

      num = rnd.Next(variability);

      double factor4 = (basic + num) / 100.0;

      num = rnd.Next(variability);

      double factor5 = (basic + num) / 100.0;

      num = rnd.Next(variability);

      double factor6 = (basic + num) / 100.0;

      num = rnd.Next(variability);

      double factor7 = (basic + num) / 100.0;

      // Multiple out the various items by the factors

      double move1 = factor1 * distance;

      double pitch1 = factor2 * kBasePitch;

      double pitch2 = factor3 * kBasePitch;

      double pitch3 = factor4 * kBasePitch;

      double roll1 = factor5 * 2 * Math.PI;

      double roll2 = roll1 + (factor6 * kBaseRoll);

      double roll3 = roll1 + roll2 + (factor7 * kBaseRoll);

      // Width of the trunk/branch is a tenth of

      // of the length

      te.SetPenWidth(move1 * kBranchWidth);

      te.SetPenColor(kWoodColor);

      te.PenDown();

      // Draw the main trunk/branch

      te.Move(move1);

      // Draw the first sub-tree

      te.Roll(roll1);

      te.Pitch(pitch1);

      Random3DTree(te, distance * kBranchFactor, variability);

      te.Pitch(-pitch1);

      te.Roll(-roll1);

      // Draw the second sub-tree

      te.Roll(roll2);

      te.Pitch(pitch2);

      Random3DTree(te, distance * kBranchFactor, variability);

      te.Pitch(-pitch2);

      te.Roll(-roll2);

      // Draw the third sub-tree

      te.Roll(roll3);

      te.Pitch(pitch3);

      Random3DTree(te, distance * kBranchFactor, variability);

      te.Pitch(-pitch3);

      te.Roll(-roll3);

      // Draw back down to the start of this sub-

      // tree, with the same thickness, as this

      // may have changed in deeper sub-trees

      te.PenUp();

      te.Move(-move1);

    }

    [CommandMethod("3DT")]

    static public void ThreeDimensionalTree()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      double treeLength;

      Point3d position;

      int variability;

      if (!GetTreeInfo(

            out position,

            out treeLength,

            out variability

            )

          )

        return;

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        using (te)

        {

          // Draw a random fractal tree

          te.Position = position;

          te.Pitch(Math.PI / -2);

          Random3DTree(te, treeLength, variability);

        }

        tr.Commit();

      }

    }

  }

}

Bear in mind that the trees created are, once again, pretty heavy models given the level of detail. You wouldn't draw trees this way in a real-world model, for instance - it would add significant bloat to your designs.

Now for some trees created by the 3DT command, taking the default options.

First in plan view:

Then in full 3D:

We can also use AutoCAD's sun implementation to see our trees' shadows (in this case at around 2:30pm in California):

Getting the trees to draw properly was quite a challenge. Along the way there were some very interesting (even beautiful) failures... Here are a couple, for fun:

I especially liked this one:

Turtle fractals in AutoCAD using .NET - Part 5

Once again I've ended up extending this series in a way I didn't originally expect to (and yes, that's a good thing :-). Here are parts 1, 2, 3 and 4, as well as the post that started it all.

After thinking about my initial 3D implementation in Part 4, I realised that implementing pen colours and widths would actually be relatively easy. Here's the idea:

• Each section of a different width and/or pen colour is actually a separate extruded solid
  • Whenever we start a new section we start off by creating a circular profile of the current pen width at the start
  • When we terminate that section - by changing the pen colour or width - we extrude the profile along the Polyline3d defining the section's path
    • This extruded Solid3d will be the colour of the pen, of course
  • We then erase the original polyline

In order to achieve this, we now have a TerminateCurrentSection() helper function, which we call whenever the pen width or colour changes, and when we are done with the TurtleEngine, of course. For this last part we've changed the TurtleEngine to implement IDisposable: this gives us the handy Dispose() method to implement (which simply calls TerminateCurrentSection()), and we can the add the using() statement to control the TurtleEngine's lifetime. One important point: we need to Dispose of the TurtleEngine before we commit the transaction, otherwise it won't work properly.

Here's the modified C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Colors;

using System;

namespace TurtleGraphics

{

  // This class encapsulates pen

  // information and will be

  // used by our TurtleEngine

  class Pen

  {

    // Private members

    private Color m_color;

    private double m_width;

    private bool m_down;

    // Public properties

    public Color Color

    {

      get { return m_color; }

      set { m_color = value; }

    }

    public double Width

    {

      get { return m_width; }

      set { m_width = value; }

    }

    public bool Down

    {

      get { return m_down; }

      set { m_down = value; }

    }

    // Constructor

    public Pen()

    {

      m_color =

        Color.FromColorIndex(ColorMethod.ByAci, 0);

      m_width = 0.0;

      m_down = false;

    }

  }

  // The main Turtle Graphics engine

  class TurtleEngine : IDisposable

  {

    // Private members

    private Transaction m_trans;

    private Polyline3d m_poly;

    private Circle m_profile;

    private Pen m_pen;

    private CoordinateSystem3d m_ecs;

    private bool m_updateGraphics;

    // Public properties

    public Point3d Position

    {

      get { return m_ecs.Origin; }

      set {

        m_ecs =

          new CoordinateSystem3d(

            value,

            m_ecs.Xaxis,

            m_ecs.Yaxis

          );

      }

    }

    public Vector3d Direction

    {

      get { return m_ecs.Xaxis; }

    }

    // Constructor

    public TurtleEngine(Transaction tr)

    {

      m_pen = new Pen();

      m_trans = tr;

      m_poly = null;

      m_profile = null;

      m_ecs =

        new CoordinateSystem3d(

          Point3d.Origin,

          Vector3d.XAxis,

          Vector3d.YAxis

        );

      m_updateGraphics = false;

    }

    public void Dispose()

    {

      TerminateCurrentSection();

    }

    // Public methods

    public void Turn(double angle)

    {

      // Rotate our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Zaxis,

          Position

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis.TransformBy(mat),

          m_ecs.Yaxis.TransformBy(mat)

        );

    }

    public void Pitch(double angle)

    {

      // Pitch in our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Yaxis,

          m_ecs.Origin

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis.TransformBy(mat),

          m_ecs.Yaxis

        );

    }

    public void Roll(double angle)

    {

      // Roll along our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Xaxis,

          m_ecs.Origin

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis,

          m_ecs.Yaxis.TransformBy(mat)

        );

    }

    public void Move(double distance)

    {

      // Move the cursor by a specified

      // distance in the direction in

      // which we're pointing

      Point3d oldPos = m_ecs.Origin;

      Point3d newPos = oldPos + m_ecs.Xaxis * distance;

      m_ecs =

        new CoordinateSystem3d(

          newPos,

          m_ecs.Xaxis,

          m_ecs.Yaxis

        );

      // If the pen is down, we draw something

      if (m_pen.Down)

        GenerateSegment(oldPos, newPos);

    }

    public void PenDown()

    {

      m_pen.Down = true;

    }

    public void PenUp()

    {

      m_pen.Down = false;

      // We'll start a new entity with the next

      // use of the pen

      TerminateCurrentSection();

    }

    public void SetPenWidth(double width)

    {

      m_pen.Width = width;

      TerminateCurrentSection();

    }

    public void SetPenColor(int idx)

    {

      // Right now we just use an ACI,

      // to make the code simpler

      Color col =

        Color.FromColorIndex(

          ColorMethod.ByAci,

          (short)idx

        );

      // If we have to change the color,

      // we'll start a new entity

      // (if the entity type we're creating

      // supports per-segment colors, we

      // don't need to do this)

      if (col != m_pen.Color)

      {

        TerminateCurrentSection();

        m_pen.Color = col;

      }

    }

    // Internal helper to generate geometry

    private void GenerateSegment(

      Point3d oldPos, Point3d newPos)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Autodesk.AutoCAD.ApplicationServices.

      TransactionManager tm =

        doc.TransactionManager;

      // Create the current object, if there is none

      if (m_poly == null)

      {

        BlockTable bt =

          (BlockTable)m_trans.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

        BlockTableRecord ms =

          (BlockTableRecord)m_trans.GetObject(

            bt[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite

          );

        // Create the polyline

        m_poly = new Polyline3d();

        m_poly.Color = m_pen.Color;

        // Add the polyline to the database

        ms.AppendEntity(m_poly);

        m_trans.AddNewlyCreatedDBObject(m_poly, true);

        // Add the first vertex

        PolylineVertex3d vert =

          new PolylineVertex3d(oldPos);

        m_poly.AppendVertex(vert);

        m_trans.AddNewlyCreatedDBObject(vert, true);

        m_profile =

          new Circle(oldPos, Direction, m_pen.Width);

        ms.AppendEntity(m_profile);

        m_trans.AddNewlyCreatedDBObject(m_profile, true);

        m_profile.DowngradeOpen();

      }

      // Add the new vertex

      PolylineVertex3d vert2 =

        new PolylineVertex3d(newPos);

      m_poly.AppendVertex(vert2);

      m_trans.AddNewlyCreatedDBObject(vert2, true);

      // Display the graphics, to avoid long,

      // black-box operations

      if (m_updateGraphics)

      {

        tm.QueueForGraphicsFlush();

        tm.FlushGraphics();

        ed.UpdateScreen();

      }

    }

    // Internal helper to generate 3D geometry

    private void TerminateCurrentSection()

    {

      if (m_profile != null && m_poly != null)

      {

        Document doc =

          Application.DocumentManager.MdiActiveDocument;

        Database db = doc.Database;

        Editor ed = doc.Editor;

        try

        {

          // Generate a Region from our circular profile

          DBObjectCollection col =

            new DBObjectCollection();

          col.Add(m_profile);

          DBObjectCollection res =

            Region.CreateFromCurves(col);

          Region reg =

            res[0] as Region;

          if (reg != null)

          {

            BlockTable bt =

              (BlockTable)m_trans.GetObject(

                db.BlockTableId,

                OpenMode.ForRead

              );

            BlockTableRecord ms =

              (BlockTableRecord)m_trans.GetObject(

                bt[BlockTableRecord.ModelSpace],

                OpenMode.ForWrite

              );

            // Extrude our Region along the Polyline3d path

            Solid3d sol = new Solid3d();

            sol.ExtrudeAlongPath(reg, m_poly, 0.0);

            sol.Color = m_pen.Color;

            // Add the generated Solid3d to the database

            ms.AppendEntity(sol);

            m_trans.AddNewlyCreatedDBObject(sol, true);

            // Get rid of the Region, profile and path

            reg.Dispose();

            m_profile.UpgradeOpen();

            m_profile.Erase();

            m_poly.Erase();

          }

        }

        catch (System.Exception ex)

        {

          ed.WriteMessage(

            "\nException: {0}",

            ex.Message

          );

        }

      }

      m_profile = null;

      m_poly = null;

    }

  }

  public class Commands

  {

    [CommandMethod("CB")]

    static public void Cube()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        using (te)

        {

          // Draw a simple 3D cube

          te.SetPenWidth(5.0);

          te.PenDown();

          for (int i = 0; i < 4; i++)

          {

            for (int j = 0; j < 4; j++)

            {

              // Only draw some of the segments

              // (this stops overlap)

              if (i % 2 == 0 || j % 2 == 0)

                te.PenDown();

              else

                te.PenUp();

              te.SetPenColor(i+j+1);

              te.Move(100);

              te.Turn(Math.PI / 2);

            }

            te.PenUp();

            te.Move(100);

            te.Pitch(Math.PI / -2);

          }

        }

        tr.Commit();

      }

    }

    static private int CubesPerLevel(int level)

    {

      if (level == 0)

        return 0;

      else

        return 2 * CubesPerLevel(level - 1) + 1;

    }

    static public bool GetHilbertInfo(

      out Point3d position,

      out double size,

      out int level

    )

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      size = 0;

      level = 0;

      position = Point3d.Origin;

      PromptPointOptions ppo =

        new PromptPointOptions(

          "\nSelect base point of Hilbert cube: "

        );

      PromptPointResult ppr =

        ed.GetPoint(ppo);

      if (ppr.Status != PromptStatus.OK)

        return false;

      position = ppr.Value;

      PromptDoubleOptions pdo =

        new PromptDoubleOptions(

          "\nEnter size <100>: "

        );

      pdo.AllowNone = true;

      PromptDoubleResult pdr =

        ed.GetDouble(pdo);

      if (pdr.Status != PromptStatus.None &&

          pdr.Status != PromptStatus.OK)

        return false;

      if (pdr.Status == PromptStatus.OK)

        size = pdr.Value;

      else

        size = 100;

      PromptIntegerOptions pio =

        new PromptIntegerOptions(

          "\nEnter level <5>: "

        );

      pio.AllowNone = true;

      pio.LowerLimit = 1;

      pio.UpperLimit = 10;

      PromptIntegerResult pir =

        ed.GetInteger(pio);

      if (pir.Status != PromptStatus.None &&

          pir.Status != PromptStatus.OK)

        return false;

      if (pir.Status == PromptStatus.OK)

        level = pir.Value;

      else

        level = 5;

      return true;

    }

    private static void Hilbert(

      TurtleEngine te, double size, int level)

    {

      if (level > 0)

      {

        te.SetPenColor(level);

        int newLevel = level - 1;

        te.Pitch(Math.PI / -2);       // Down Pitch 90

        te.Roll(Math.PI / -2);        // Left Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.SetPenColor(level);

        te.Move(size);                // Forward Size

        te.Pitch(Math.PI / -2);       // Down Pitch 90

        te.Roll(Math.PI / -2);        // Left Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.SetPenColor(level);

        te.Move(size);                // Forward Size

        Hilbert(te, size, newLevel);  // Recurse

        te.Turn(Math.PI / -2);        // Left Turn 90

        te.Move(size);                // Forward Size

        te.Pitch(Math.PI / -2);       // Down Pitch 90

        te.Roll(Math.PI / 2);         // Right Roll 90

        te.Roll(Math.PI / 2);         // Right Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.SetPenColor(level);

        te.Move(size);                // Forward Size

        Hilbert(te, size, newLevel);  // Recurse

        te.SetPenColor(level);

        te.Pitch(Math.PI / 2);        // Up Pitch 90

        te.Move(size);                // Forward Size

        te.Turn(Math.PI / 2);         // Right Turn 90

        te.Roll(Math.PI / 2);         // Right Roll 90

        te.Roll(Math.PI / 2);         // Right Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.SetPenColor(level);

        te.Move(size);                // Forward Size

        Hilbert(te, size, newLevel);  // Recurse

        te.SetPenColor(level);

        te.Turn(Math.PI / -2);        // Left Turn 90

        te.Move(size);                // Forward Size

        te.Roll(Math.PI / 2);         // Right Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.SetPenColor(level);

        te.Turn(Math.PI / -2);        // Left Turn 90

        te.Roll(Math.PI / 2);         // Right Roll 90

      }

    }

    [CommandMethod("DH")]

    static public void DrawHilbert()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      double size;

      int level;

      Point3d position;

      if (!GetHilbertInfo(out position, out size, out level))

        return;

      int cbl = CubesPerLevel(level);

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        using (te)

        {

          // Draw a Hilbert cube

          te.Position = position;

          te.SetPenWidth(10.0 / cbl);

          te.PenDown();

          Hilbert(te, size / cbl, level);

        }

        tr.Commit();

      }

    }

  }

}

Here are the results of the modified CB command, which now has coloured segments with a width:

Here's what we get from the DH command. This command now runs pretty slowly for the higher levels - it is doing a lot of work, after all - and only runs at all because we're using separate sections by changing the colour regularly. You'll notice that the pen width is set according to the level, as the finer the detail, the finer the pen width needed.

First the plan view:

Then the full 3D view:

Here's a close-up of the level 5 cube:

A word of caution: some of these higher levels are extremely resource-intensive. Please do not attempt to play around with something like this while working on something you don't want to lose: there is always a slim chance of the application (and even the system, if you're really unlucky) being brought down when system resources become scarce.

Turtle fractals in AutoCAD using .NET - Part 4

I just couldn't resist coming back to this fun (at least for me :-) series... for reference here are parts 1, 2 and 3, while the series really started here.

There are two main places I wanted to take this implementation: firstly it really needed to be made 3D, which is the focus of this post, and I still then want to take it further by implementing a turtle graphics-oriented language (one could probably call it a Domain Specific Language, the domain being turtle graphics), which is likely to be a subset or variant of Logo. This is likely to be done using F#, but we'll see when I get around to it... :-)

Firstly, some concepts: with a 2D turtle graphics system we only really need two operations, Move and Turn. As we update our implementation to cope with that pesky third dimension we need to extend the set of operations to include Pitch and Roll. So our "turtle" needs to have more than just a position and a direction, it needs its own positioning matrix (essentially its own coordinate system). Think of the turtle as having its own little UCS icon travelling around with it (the direction being the X axis): we can then implement Turn as a rotation around its current Z axis, Pitch as a rotation around its Y axis and Roll as a rotation around its X axis. Each of these operations will, of course, update the coordinate system so that it's pointing somewhere different.

The below implementation maintains the Direction property, but it's now read-only: the underlying implementation is now via a CoordinateSystem3d object member variable (m_ecs). Each of the Move, Turn, Pitch and Roll operations adjusts the coordinate system, as does setting the Position property.

As for the geometry that we create via the turtle's movements: Polyline objects are inherently 2D, so the new implementation makes use of Polyline3d objects instead. Polyline3d objects contain PolylineVertex3d objects, and have slightly different requirements about database residency as we're adding our vertices, but the fundamental approach is not really any different. A couple of points to note... as pen thickness doesn't really make sense in 3D (at least for Polyline3d objects - we could, of course, get clever with extruding profiles along our paths, if we really wanted to), I've decided to ignore it, for now. The same is true of pen colour. These are both left as enhancements for the future.

Here's the updated C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Colors;

using System;

namespace TurtleGraphics

{

  // This class encapsulates pen

  // information and will be

  // used by our TurtleEngine

  class Pen

  {

    // Private members

    private Color m_color;

    private double m_width;

    private bool m_down;

    // Public properties

    public Color Color

    {

      get { return m_color; }

      set { m_color = value; }

    }

    public double Width

    {

      get { return m_width; }

      set { m_width = value; }

    }

    public bool Down

    {

      get { return m_down; }

      set { m_down = value; }

    }

    // Constructor

    public Pen()

    {

      m_color =

        Color.FromColorIndex(ColorMethod.ByAci, 0);

      m_width = 0.0;

      m_down = false;

    }

  }

  // The main Turtle Graphics engine

  class TurtleEngine

  {

    // Private members

    private Transaction m_trans;

    private Polyline3d m_poly;

    private Pen m_pen;

    private CoordinateSystem3d m_ecs;

    private bool m_updateGraphics;

    // Public properties

    public Point3d Position

    {

      get { return m_ecs.Origin; }

      set {

        m_ecs =

          new CoordinateSystem3d(

            value,

            m_ecs.Xaxis,

            m_ecs.Yaxis

          );

      }

    }

    public Vector3d Direction

    {

      get { return m_ecs.Xaxis; }

    }

    // Constructor

    public TurtleEngine(Transaction tr)

    {

      m_pen = new Pen();

      m_trans = tr;

      m_poly = null;

      m_ecs =

        new CoordinateSystem3d(

          Point3d.Origin,

          Vector3d.XAxis,

          Vector3d.YAxis

        );

      m_updateGraphics = false;

    }

    // Public methods

    public void Turn(double angle)

    {

      // Rotate our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Zaxis,

          Position

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis.TransformBy(mat),

          m_ecs.Yaxis.TransformBy(mat)

        );

    }

    public void Pitch(double angle)

    {

      // Pitch in our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Yaxis,

          m_ecs.Origin

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis.TransformBy(mat),

          m_ecs.Yaxis

        );

    }

    public void Roll(double angle)

    {

      // Roll along our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          m_ecs.Xaxis,

          m_ecs.Origin

        );

      m_ecs =

        new CoordinateSystem3d(

          m_ecs.Origin,

          m_ecs.Xaxis,

          m_ecs.Yaxis.TransformBy(mat)

        );

    }

    public void Move(double distance)

    {

      // Move the cursor by a specified

      // distance in the direction in

      // which we're pointing

      Point3d oldPos = m_ecs.Origin;

      Point3d newPos = oldPos + m_ecs.Xaxis * distance;

      m_ecs =

        new CoordinateSystem3d(

          newPos,

          m_ecs.Xaxis,

          m_ecs.Yaxis

        );

      // If the pen is down, we draw something

      if (m_pen.Down)

        GenerateSegment(oldPos, newPos);

    }

    public void PenDown()

    {

      m_pen.Down = true;

    }

    public void PenUp()

    {

      m_pen.Down = false;

      // We'll start a new entity with the next

      // use of the pen

      m_poly = null;

    }

    public void SetPenWidth(double width)

    {

      // Pen width is not currently implemented in 3D

      //m_pen.Width = width;

    }

    public void SetPenColor(int idx)

    {

      // Right now we just use an ACI,

      // to make the code simpler

      Color col =

        Color.FromColorIndex(

          ColorMethod.ByAci,

          (short)idx

        );

      // If we have to change the color,

      // we'll start a new entity

      // (if the entity type we're creating

      // supports per-segment colors, we

      // don't need to do this)

      if (col != m_pen.Color)

      {

        m_poly = null;

        m_pen.Color = col;

      }

    }

    // Internal helper to generate geometry

    // (this could be optimised to keep the

    // object we're generating open, rather

    // than having to reopen it each time)

    private void GenerateSegment(

      Point3d oldPos, Point3d newPos)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Autodesk.AutoCAD.ApplicationServices.

      TransactionManager tm =

        doc.TransactionManager;

      // Create the current object, if there is none

      if (m_poly == null)

      {

        BlockTable bt =

          (BlockTable)m_trans.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

        BlockTableRecord ms =

          (BlockTableRecord)m_trans.GetObject(

            bt[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite

          );

        // Create the polyline

        m_poly = new Polyline3d();

        m_poly.Color = m_pen.Color;

        // Add the polyline to the database

        ms.AppendEntity(m_poly);

        m_trans.AddNewlyCreatedDBObject(m_poly, true);

        // Add the first vertex

        PolylineVertex3d vert =

          new PolylineVertex3d(oldPos);

        m_poly.AppendVertex(vert);

        m_trans.AddNewlyCreatedDBObject(vert, true);

      }

      // Add the new vertex

      PolylineVertex3d vert2 =

        new PolylineVertex3d(newPos);

      m_poly.AppendVertex(vert2);

      m_trans.AddNewlyCreatedDBObject(vert2, true);

      // Display the graphics, to avoid long,

      // black-box operations

      if (m_updateGraphics)

      {

        tm.QueueForGraphicsFlush();

        tm.FlushGraphics();

        ed.UpdateScreen();

      }

    }

  }

  public class Commands

  {

    [CommandMethod("CB")]

    static public void Cube()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        // Draw a simple 3D cube

        te.PenDown();

        for (int i=0; i < 4; i++)

        {

          for (int j=0; j < 4; j++)

          {

            te.Move(100);

            te.Turn(Math.PI / 2);

          }

          te.Move(100);

          te.Pitch(Math.PI / -2);

        }

        tr.Commit();

      }

    }

    static private int CubesPerLevel(int level)

    {

      if (level == 0)

        return 0;

      else

        return 2 * CubesPerLevel(level - 1) + 1;

    }

    static public bool GetHilbertInfo(

      out Point3d position,

      out double size,

      out int level

    )

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      size = 0;

      level = 0;

      position = Point3d.Origin;

      PromptPointOptions ppo =

        new PromptPointOptions(

          "\nSelect base point of Hilbert cube: "

        );

      PromptPointResult ppr =

        ed.GetPoint(ppo);

      if (ppr.Status != PromptStatus.OK)

        return false;

      position = ppr.Value;

      PromptDoubleOptions pdo =

        new PromptDoubleOptions(

          "\nEnter size <100>: "

        );

      pdo.AllowNone = true;

      PromptDoubleResult pdr =

        ed.GetDouble(pdo);

      if (pdr.Status != PromptStatus.None &&

          pdr.Status != PromptStatus.OK)

        return false;

      if (pdr.Status == PromptStatus.OK)

        size = pdr.Value;

      else

        size = 100;

      PromptIntegerOptions pio =

        new PromptIntegerOptions(

          "\nEnter level <5>: "

        );

      pio.AllowNone = true;

      pio.LowerLimit = 1;

      pio.UpperLimit = 10;

      PromptIntegerResult pir =

        ed.GetInteger(pio);

      if (pir.Status != PromptStatus.None &&

          pir.Status != PromptStatus.OK)

        return false;

      if (pir.Status == PromptStatus.OK)

        level = pir.Value;

      else

        level = 5;

      return true;

    }

    private static void Hilbert(

      TurtleEngine te, double size, int level)

    {

      if (level > 0)

      {

        int newLevel = level - 1;

        te.Pitch(Math.PI / -2);       // Down Pitch 90

        te.Roll(Math.PI / -2);        // Left Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.Move(size);                // Forward Size

        te.Pitch(Math.PI / -2);       // Down Pitch 90

        te.Roll(Math.PI / -2);        // Left Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.Move(size);                // Forward Size

        Hilbert(te, size, newLevel);  // Recurse

        te.Turn(Math.PI / -2);        // Left Turn 90

        te.Move(size);                // Forward Size

        te.Pitch(Math.PI / -2);       // Down Pitch 90

        te.Roll(Math.PI / 2);         // Right Roll 90

        te.Roll(Math.PI / 2);         // Right Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.Move(size);                // Forward Size

        Hilbert(te, size, newLevel);  // Recurse

        te.Pitch(Math.PI / 2);        // Up Pitch 90

        te.Move(size);                // Forward Size

        te.Turn(Math.PI / 2);         // Right Turn 90

        te.Roll(Math.PI / 2);         // Right Roll 90

        te.Roll(Math.PI / 2);         // Right Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.Move(size);                // Forward Size

        Hilbert(te, size, newLevel);  // Recurse

        te.Turn(Math.PI / -2);        // Left Turn 90

        te.Move(size);                // Forward Size

        te.Roll(Math.PI / 2);         // Right Roll 90

        Hilbert(te, size, newLevel);  // Recurse

        te.Turn(Math.PI / -2);        // Left Turn 90

        te.Roll(Math.PI / 2);         // Right Roll 90

      }

    }

    [CommandMethod("DH")]

    static public void DrawHilbert()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      double size;

      int level;

      Point3d position;

      if (!GetHilbertInfo(out position, out size, out level))

        return;

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        // Draw a Hilbert cube

        te.Position = position;

        te.PenDown();

        Hilbert(te, size / CubesPerLevel(level), level);

        tr.Commit();

      }

    }

  }

}

To try out this new engine, I implemented a few commands: one draws a simply cube (the CB command), while the other does something much more interesting - it draws a Hilbert curve in 3D (I've called it a Hilbert cube, although that's not really the official terminology). Check out the DH command above and its results, below.

Here are the results of running the DH command for levels 1-6. Level 7 is as close to a solid black cube as you can get without zooming very, very closely, so that's where I stopped.

First the plan view:

Now for 3D:

For fun, I took the level 4 cube and drew a circle at one its end-points:

Here's what happens when we EXTRUDE the circle along the Polyline3d path, setting the Visual Style to conceptual:

A final note, to close out today's topic: a very useful (and fascinating) reference for me during this implementation has been The Algorithmic Beauty of Plants, a volume by Przemyslaw Prusinkiewicz and Aristid Lindenmayer. While it is unfortunately no longer in print, it is thankfully available as a free download.

Turtle fractals in AutoCAD using .NET - Part 3

In the introductory post we first looked at a simple turtle graphics engine for AutoCAD, which was followed up by this series looking at using it to generate fractals (here are parts 1 & 2).

This post continues the organic fractal theme, by looking at another fractal found in nature, the humble fern. I found some simple Logo code in a presentation on the web:

to fern :size

if :size < 4 [stop]

fd :size / 25

lt 90 fern :size * .3

rt 90

rt 90 fern :size * .3

lt 90 fern :size * .85

bk :size / 25

end

This - when translated to use our turtle engine inside AutoCAD - creates a somewhat straight, unnatural-looking fern:

To make things a little more interesting, I generalised out some of the parameters to allow easy tweaking within the code. Here's the C# code including the complete TurtleEngine implementation, as before:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Colors;

using System;

namespace TurtleGraphics

{

  // This class encapsulates pen

  // information and will be

  // used by our TurtleEngine

  class Pen

  {

    // Private members

    private Color m_color;

    private double m_width;

    private bool m_down;

    // Public properties

    public Color Color

    {

      get { return m_color; }

      set { m_color = value; }

    }

    public double Width

    {

      get { return m_width; }

      set { m_width = value; }

    }

    public bool Down

    {

      get { return m_down; }

      set { m_down = value; }

    }

    // Constructor

    public Pen()

    {

      m_color =

        Color.FromColorIndex(ColorMethod.ByAci, 0);

      m_width = 0.0;

      m_down = false;

    }

  }

  // The main Turtle Graphics engine

  class TurtleEngine

  {

    // Private members

    private Transaction m_trans;

    private Polyline m_poly;

    private Pen m_pen;

    private Point3d m_position;

    private Vector3d m_direction;

    private bool m_updateGraphics;

    // Public properties

    public Point3d Position

    {

      get { return m_position; }

      set { m_position = value; }

    }

    public Vector3d Direction

    {

      get { return m_direction; }

      set { m_direction = value; }

    }

    // Constructor

    public TurtleEngine(Transaction tr)

    {

      m_pen = new Pen();

      m_trans = tr;

      m_poly = null;

      m_position = Point3d.Origin;

      m_direction = new Vector3d(1.0, 0.0, 0.0);

      m_updateGraphics = false;

    }

    // Public methods

    public void Turn(double angle)

    {

      // Rotate our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          Vector3d.ZAxis,

          Position

        );

      Direction =

        Direction.TransformBy(mat);

    }

    public void Move(double distance)

    {

      // Move the cursor by a specified

      // distance in the direction in

      // which we're pointing

      Point3d oldPos = Position;

      Position += Direction * distance;

      // If the pen is down, we draw something

      if (m_pen.Down)

        GenerateSegment(oldPos, Position);

    }

    public void PenDown()

    {

      m_pen.Down = true;

    }

    public void PenUp()

    {

      m_pen.Down = false;

      // We'll start a new entity with the next

      // use of the pen

      m_poly = null;

    }

    public void SetPenWidth(double width)

    {

      m_pen.Width = width;

    }

    public void SetPenColor(int idx)

    {

      // Right now we just use an ACI,

      // to make the code simpler

      Color col =

        Color.FromColorIndex(

          ColorMethod.ByAci,

          (short)idx

        );

      // If we have to change the color,

      // we'll start a new entity

      // (if the entity type we're creating

      // supports per-segment colors, we

      // don't need to do this)

      if (col != m_pen.Color)

      {

        m_poly = null;

        m_pen.Color = col;

      }

    }

    // Internal helper to generate geometry

    // (this could be optimised to keep the

    // object we're generating open, rather

    // than having to reopen it each time)

    private void GenerateSegment(

      Point3d oldPos, Point3d newPos)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Autodesk.AutoCAD.ApplicationServices.

      TransactionManager tm =

        doc.TransactionManager;

      Plane plane;

      // Create the current object, if there is none

      if (m_poly == null)

      {

        BlockTable bt =

          (BlockTable)m_trans.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

        BlockTableRecord ms =

          (BlockTableRecord)m_trans.GetObject(

            bt[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite

          );

        // Create the polyline

        m_poly = new Polyline();

        m_poly.Color = m_pen.Color;

        // Define its plane

        plane = new Plane(

          m_poly.Ecs.CoordinateSystem3d.Origin,

          m_poly.Ecs.CoordinateSystem3d.Zaxis

        );

        // Add the first vertex

        m_poly.AddVertexAt(

          0, oldPos.Convert2d(plane),

          0.0, m_pen.Width, m_pen.Width

        );

        // Add the polyline to the database

        ms.AppendEntity(m_poly);

        m_trans.AddNewlyCreatedDBObject(m_poly, true);

      }

      else

      {

        // Calculate its plane

        plane = new Plane(

          m_poly.Ecs.CoordinateSystem3d.Origin,

          m_poly.Ecs.CoordinateSystem3d.Zaxis

        );

      }

      // Make sure the previous vertex has its

      // width set appropriately

      if (m_pen.Width > 0.0)

      {

        m_poly.SetStartWidthAt(

          m_poly.NumberOfVertices - 1,

          m_pen.Width

        );

        m_poly.SetEndWidthAt(

          m_poly.NumberOfVertices - 1,

          m_pen.Width

        );

      }

      // Add the new vertex

      m_poly.AddVertexAt(

        m_poly.NumberOfVertices,

        newPos.Convert2d(plane),

        0.0, m_pen.Width, m_pen.Width

      );

      // Display the graphics, to avoid long,

      // black-box operations

      if (m_updateGraphics)

      {

        tm.QueueForGraphicsFlush();

        tm.FlushGraphics();

        ed.UpdateScreen();

      }

    }

  }

  public class Commands

  {

    static void Fern(

      TurtleEngine te,

      double distance

    )

    {

      const double minDist = 0.3;

      const double widthFactor = 0.1;

      const double stemFactor = 0.04;

      const double restFactor = 0.85;

      const double branchFactor = 0.3;

      const int stemSegs = 5;

      const int stemSegAngle = 1;

      if (distance < minDist)

        return;

      // Width of the trunk/branch is a fraction

      // of the length

      te.SetPenWidth(

        distance * stemFactor * widthFactor

      );

      // Draw the stem

      for (int i = 0; i < stemSegs; i++)

      {

        te.Move(distance * stemFactor / stemSegs);

        if (i < stemSegs - 1)

          te.Turn(-stemSegAngle * Math.PI / 180);

      }

      // Draw the left-hand sub-fern

      te.Turn(Math.PI / 2);

      Fern(te, distance * branchFactor);

      // Draw the right-hand sub-fern

      te.Turn(-Math.PI);

      Fern(te, distance * branchFactor);

      // Draw the rest of the fern to the front

      te.Turn(Math.PI / 2);

      Fern(te, distance * restFactor);

      // Draw back down to the start of this sub-

      // fern, with the same thickness, as this

      // may have changed in deeper sub-ferns

      te.SetPenWidth(

        distance * stemFactor * widthFactor

      );

      for (int i = 0; i < stemSegs; i++)

      {

        te.Move(-distance * stemFactor / stemSegs);

        if (i < stemSegs - 1)

          te.Turn(stemSegAngle * Math.PI / 180);

      }

    }

    static public bool GetFernInfo(

      out Point3d position,

      out double treeLength

    )

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      treeLength = 0;

      position = Point3d.Origin;

      PromptPointOptions ppo =

        new PromptPointOptions(

          "\nSelect base point of fern: "

        );

      PromptPointResult ppr =

        ed.GetPoint(ppo);

      if (ppr.Status != PromptStatus.OK)

        return false;

      position = ppr.Value;

      PromptDoubleOptions pdo =

        new PromptDoubleOptions(

          "\nEnter fern length <100>: "

        );

      pdo.AllowNone = true;

      PromptDoubleResult pdr =

        ed.GetDouble(pdo);

      if (pdr.Status != PromptStatus.None &&

          pdr.Status != PromptStatus.OK)

        return false;

      if (pdr.Status == PromptStatus.OK)

        treeLength = pdr.Value;

      else

        treeLength = 100;

      return true;

    }

    [CommandMethod("FF")]

    static public void FractalFern()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      double fernLength;

      Point3d position;

      if (!GetFernInfo(out position, out fernLength))

        return;

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        // Draw a fractal fern

        te.Position = position;

        te.SetPenColor(92);

        te.SetPenWidth(0);

        te.Turn(Math.PI / 2);

        te.PenDown();

        Fern(te, fernLength);

        tr.Commit();

      }

    }

  }

}

When we run the FF command, selecting a location and the default tree length, we see a more natural (although in no way random) form:

Tweaking the stemSegAngle constant to be -2 instead of 1 gives a further differentiated result:

Incidentally, to get the original, "straight" fern, simply change the stemSegs constant to 1. The curved ferns will each take n times as much space in memory/on disk as the straight ones (where n is the value of stemSegs). This is because we're not storing actual curves, but using multiple straight line segments.

Any of the constants in the Fern() function could be presented for the user to enter, of course (i.e. populated by the GetFernInfo() function and passed as parameters into the Fern() function).

Turtle fractals in AutoCAD using .NET - Part 2

This series start with this initial post, where we looked at an implementation of a simple turtle graphics engine inside AutoCAD, and followed on with this previous post, where we refined the engine and looked at how we could use it to generate complex fractals with relatively little code.

In this post we take a further look at fractal generation using the turtle graphic engine, with the particular focus on introducing randomness to generate more realistic, organic forms. On a side note, fractals and the use of randomness in design are two of my favourite topics, so this post is hitting a sweet spot, for me. :-)

So where to start when generating organic forms? The simplest, "classic" example, in my view, is to generate trees. Trees lend themselves to automatic generation, as - in 2D, at least - they are a sequence of simple 2-way forks (at least the way I draw them, they are :-).

I picked up some simple Logo code from this site (yes, it does indeed say "fractals for children" in the title :-)

if :distance < 5 [stop]

forward :distance

right 30

tree :distance-10

left 60

tree :distance-10

right 30

back :distance

This is easy to turn into C# code harnessing our TurtleEngine, with the addition of a proportional trunk/branch width (we take the width as a tenth of the length). See the Tree() function in the code listing below. The results of this procedure (which you call via the FT command) are interesting enough, if a little perfect:

You will notice that the tree is created as a single Polyline, which is a result of us back-tracking over previous segments with the pen down, rather than up. You can see this from this image showing the tree selected:

The FT command will create the same results every single time (assuming you specify the same tree length), which may or may not be what you're after.

So let's go and add some randomness, to make life a little more interesting. This modified function in the below code, named RandomTree(), generates a separate random factor to apply to the trunk/branch length (and therefore the width, as this is proportional to the length), and to the angle of each of the two branches sprouting from the current trunk or branch. The "variability" is specified by the user for all our random factors, but we could go further and tweak it for the length and for each of the angles.

Here's the C# code, including command definitions and the TurtleEngine we refined in the last post:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Colors;

using System;

namespace TurtleGraphics

{

  // This class encapsulates pen

  // information and will be

  // used by our TurtleEngine

  class Pen

  {

    // Private members

    private Color m_color;

    private double m_width;

    private bool m_down;

    // Public properties

    public Color Color

    {

      get { return m_color; }

      set { m_color = value; }

    }

    public double Width

    {

      get { return m_width; }

      set { m_width = value; }

    }

    public bool Down

    {

      get { return m_down; }

      set { m_down = value; }

    }

    // Constructor

    public Pen()

    {

      m_color =

        Color.FromColorIndex(ColorMethod.ByAci, 0);

      m_width = 0.0;

      m_down = false;

    }

  }

  // The main Turtle Graphics engine

  class TurtleEngine

  {

    // Private members

    private Transaction m_trans;

    private Polyline m_poly;

    private Pen m_pen;

    private Point3d m_position;

    private Vector3d m_direction;

    private bool m_updateGraphics;

    // Public properties

    public Point3d Position

    {

      get { return m_position; }

      set { m_position = value; }

    }

    public Vector3d Direction

    {

      get { return m_direction; }

      set { m_direction = value; }

    }

    // Constructor

    public TurtleEngine(Transaction tr)

    {

      m_pen = new Pen();

      m_trans = tr;

      m_poly = null;

      m_position = Point3d.Origin;

      m_direction = new Vector3d(1.0, 0.0, 0.0);

      m_updateGraphics = false;

    }

    // Public methods

    public void Turn(double angle)

    {

      // Rotate our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          Vector3d.ZAxis,

          Position

        );

      Direction =

        Direction.TransformBy(mat);

    }

    public void Move(double distance)

    {

      // Move the cursor by a specified

      // distance in the direction in

      // which we're pointing

      Point3d oldPos = Position;

      Position += Direction * distance;

      // If the pen is down, we draw something

      if (m_pen.Down)

        GenerateSegment(oldPos, Position);

    }

    public void PenDown()

    {

      m_pen.Down = true;

    }

    public void PenUp()

    {

      m_pen.Down = false;

      // We'll start a new entity with the next

      // use of the pen

      m_poly = null;

    }

    public void SetPenWidth(double width)

    {

      m_pen.Width = width;

    }

    public void SetPenColor(int idx)

    {

      // Right now we just use an ACI,

      // to make the code simpler

      Color col =

        Color.FromColorIndex(

          ColorMethod.ByAci,

          (short)idx

        );

      // If we have to change the color,

      // we'll start a new entity

      // (if the entity type we're creating

      // supports per-segment colors, we

      // don't need to do this)

      if (col != m_pen.Color)

      {

        m_poly = null;

        m_pen.Color = col;

      }

    }

    // Internal helper to generate geometry

    // (this could be optimised to keep the

    // object we're generating open, rather

    // than having to reopen it each time)

    private void GenerateSegment(

      Point3d oldPos, Point3d newPos)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Autodesk.AutoCAD.ApplicationServices.

      TransactionManager tm =

        doc.TransactionManager;

      Plane plane;

      // Create the current object, if there is none

      if (m_poly == null)

      {

        BlockTable bt =

          (BlockTable)m_trans.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

        BlockTableRecord ms =

          (BlockTableRecord)m_trans.GetObject(

            bt[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite

          );

        // Create the polyline

        m_poly = new Polyline();

        m_poly.Color = m_pen.Color;

        // Define its plane

        plane = new Plane(

          m_poly.Ecs.CoordinateSystem3d.Origin,

          m_poly.Ecs.CoordinateSystem3d.Zaxis

        );

        // Add the first vertex

        m_poly.AddVertexAt(

          0, oldPos.Convert2d(plane),

          0.0, m_pen.Width, m_pen.Width

        );

        // Add the polyline to the database

        ms.AppendEntity(m_poly);

        m_trans.AddNewlyCreatedDBObject(m_poly, true);

      }

      else

      {

        // Calculate its plane

        plane = new Plane(

          m_poly.Ecs.CoordinateSystem3d.Origin,

          m_poly.Ecs.CoordinateSystem3d.Zaxis

        );

      }

      // Make sure the previous vertex has its

      // width set appropriately

      if (m_pen.Width > 0.0)

      {

        m_poly.SetStartWidthAt(

          m_poly.NumberOfVertices - 1,

          m_pen.Width

        );

        m_poly.SetEndWidthAt(

          m_poly.NumberOfVertices - 1,

          m_pen.Width

        );

      }

      // Add the new vertex

      m_poly.AddVertexAt(

        m_poly.NumberOfVertices,

        newPos.Convert2d(plane),

        0.0, m_pen.Width, m_pen.Width

      );

      // Display the graphics, to avoid long,

      // black-box operations

      if (m_updateGraphics)

      {

        tm.QueueForGraphicsFlush();

        tm.FlushGraphics();

        ed.UpdateScreen();

      }

    }

  }

  public class Commands

  {

    static public bool GetTreeInfo(

      out Point3d position,

      out double treeLength

    )

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      treeLength = 0;

      position = Point3d.Origin;

      PromptPointOptions ppo =

        new PromptPointOptions(

          "\nSelect base point of tree: "

        );

      PromptPointResult ppr =

        ed.GetPoint(ppo);

      if (ppr.Status != PromptStatus.OK)

        return false;

      position = ppr.Value;

      PromptDoubleOptions pdo =

        new PromptDoubleOptions(

          "\nEnter tree length <70>: "

        );

      pdo.AllowNone = true;

      PromptDoubleResult pdr =

        ed.GetDouble(pdo);

      if (pdr.Status != PromptStatus.None &&

          pdr.Status != PromptStatus.OK)

        return false;

      if (pdr.Status == PromptStatus.OK)

        treeLength = pdr.Value;

      else

        treeLength = 70;

      return true;

    }

    static void Tree(

      TurtleEngine te,

      double distance

    )

    {

      if (distance < 5.0)

        return;

      // Width of the trunk/branch is a tenth of

      // of the length

      te.SetPenWidth(distance / 10);

      // Draw the main trunk/branch

      te.Move(distance);

      // Draw the left-hand sub-tree

      te.Turn(Math.PI / 6);

      Tree(te, distance - 10);

      // Draw the right-hand sub-tree

      te.Turn(Math.PI / -3);

      Tree(te, distance - 10);

      // Turn back to the original angle

      te.Turn(Math.PI / 6);

      // Draw back down to the start of this sub-

      // tree, with the same thickness, as this

      // may have changed in deeper sub-trees

      te.SetPenWidth(distance / 10);

      te.Move(-distance);

    }

    static void RandomTree(

      TurtleEngine te,

      double distance,

      int variability

    )

    {

      if (distance < 5.0)

        return;

      // Generate 3 random factors, each on the same basis:

      //  a base amount = 100 - half the variability

      //  + a random amount from 0 to the variability

      // So a variability of 20 results in 90 to 110 (0.9-1.1)

      Random rnd = new Random();

      int basic = 100 - (variability / 2);

      int num = rnd.Next(variability);

      double factor = (basic + num) / 100.0;

      num = rnd.Next(variability);

      double factor1 = (basic + num) / 100.0;

      num = rnd.Next(variability);

      double factor2 = (basic + num) / 100.0;

      // Multiple out the various items by the factors

      double distance1 = factor * distance;

      double angle1 = factor1 * Math.PI / 6;

      double angle2 = factor2 * Math.PI / -3;

      // The last angle is the total angle

      double angle3 = angle1 + angle2;

      // Width of the trunk/branch is a tenth of

      // of the length

      te.SetPenWidth(distance1 / 10);

      // Draw the main trunk/branch

      te.Move(distance1);

      // Draw the left-hand sub-tree

      te.Turn(angle1);

      RandomTree(te, distance - 10, variability);

      // Draw the right-hand sub-tree

      te.Turn(angle2);

      RandomTree(te, distance - 10, variability);

      // Turn back to the original angle

      te.Turn(-angle3);

      // Draw back down to the start of this sub-

      // tree, with the same thickness, as this

      // may have changed in deeper sub-trees

      te.SetPenWidth(distance1 / 10);

      te.Move(-distance1);

    }

    [CommandMethod("FT")]

    static public void FractalTree()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      double treeLength;

      Point3d position;

      if (!GetTreeInfo(out position, out treeLength))

        return;

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        // Draw a fractal tree

        te.Position = position;

        te.SetPenColor(0);

        te.SetPenWidth(0);

        te.Turn(Math.PI / 2);

        te.PenDown();

        Tree(te, treeLength);

        tr.Commit();

      }

    }

    [CommandMethod("RFT")]

    static public void RandomFractalTree()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      double treeLength;

      Point3d position;

      if (!GetTreeInfo(out position, out treeLength))

        return;

      int variability = 20;

      PromptIntegerOptions pio =

        new PromptIntegerOptions(

          "\nEnter variability percentage <20>: "

        );

      pio.AllowNone = true;

      PromptIntegerResult pir =

        ed.GetInteger(pio);

      if (pir.Status != PromptStatus.None &&

          pir.Status != PromptStatus.OK)

        return;

      if (pir.Status == PromptStatus.OK)

        variability = pir.Value;

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        // Draw a random fractal tree

        te.Position = position;

        te.SetPenColor(0);

        te.SetPenWidth(0);

        te.Turn(Math.PI / 2);

        te.PenDown();

        RandomTree(te, treeLength, variability);

        tr.Commit();

      }

    }

  }

}

This is the first time the turtle engine has been used to apply widths to segments, so I did make a very minor change in the GenerateSegment() function: we need to apply the current pen width to the previous Polyline vertex, and not just the one we're adding. A minor change, but one that makes the engine behave in a more expected way.

When we run the RFT command, we can see a variety of trees get created - here's a quick sample:

These were created with the standard options (tree length of 70, variability of 20), but with different choices here you can get quite different results.

I hope this demonstrates the interesting capabilities turtle graphics bring to the area of modeling organic models via recursive fractals + randomness: while this was deliberately quite a simple example, this type of approach could be used/extended to generate other, more elaborate types of "natural" design in two and three dimensions.

Turtle fractals in AutoCAD using .NET - Part 1

This topic started in this recent post, where I introduced a simple turtle graphics engine for AutoCAD implemented in C#. My eventual aim is still to implement a subset of the Logo programming language in F#, calling through to this C# engine, but for now I've been side-tracked: I'm simply having too much fun with the engine itself and exploring the possibilities of turtle graphics inside AutoCAD - especially around the use of recursive algorithms to generate fractals.

This post and the next (and maybe more, depending on how much fun I continue to have) will be devoted to recursive algorithms for fractal generation with a cursor-based, turtle graphics system: in this post we'll start with performance-related improvements to the engine alluded to in the last post, and move on to code to generate precise fractals. The next post will take this further by looking at adding randomness to fractals, allowing us to create more organic forms.

So let's start with the engine enhancements: I mentioned last time that the previous implementation was sub-optimal, as it used a new transaction for each segment created. I did some benchmarking, to see what improvement gains were to be had by changing the implementation, and - interestingly - there was very little change when I modified the engine to maintain a single transaction when testing with the DTG command in the previous post. It turns out that the bottleneck for that particular scenario was the graphics update: refreshing the graphics after each segment drawn is extremely time-consuming, so the overhead of using separate transactions per segment didn't really impact performance. As we move on to much larger models - as we will in this post - it makes sense to perform two optimizations to the engine:

1. Turn off display of graphics during update
   • We will not flush any graphics and simply let AutoCAD take care of updating the display when we're done
2. A single transaction per execution
   • We will maintain references to a Transaction and a Polyline within our engine, instead of an ObjectId

Implementing this is very simple, as you can see below, and the client code only really needs to make one change: it needs to start its own transaction and pass that into the constructor of the TurtleEngine. This will be used, as needed, and must, of course, be committed and disposed of by the client at the end (we'll use the using statement to take care of the disposal).

Once the graphics flushing has been disabled (again, with a trivial change: I've added a Boolean variable - with a default value of false - to check before updating the graphics), we really start to see the relevance of maintaining a separate transaction, as our previous performance bottleneck has been removed. More on this later.

Onto the fractal algorithm we're implementing today, to put the engine through its paces: some of you may remember this previous pair of posts, where we looked at an implementation for generating Koch curves inside AutoCAD. In this case we're going to generate something called the Koch snowflake, which is basically a triangle with each segment divided a series of times:

The formula for calculating the number of sides is: 3 * 4^l, where l is the recursion level (at least from our perspective, a triangle is level 0, while the right-most shape above is level 5). I have kept two implementations of the engine in my project, for comparison: when using the old implementation, a level 7 Koch snowflake - which for us means a Polyline of 49,152 segments - takes 5 minutes to generate. With the new approach of maintaining a single transaction, this reduces to under 2 seconds. Which is clearly a significant change. [Note: neither of these implementations update graphics until the end - if we were to update the screen for each of the ~50K segments, we'd be waiting for hours, I suspect.]

A level 8 snowflake took just 7 seconds for my system to generate with the new version of the engine. I limited the level selection to 8, not because it would take too long to generate, but because unless you disable rollover highlighting AutoCAD is likely to grind to a halt for a number of seconds when you hover over an object of this complexity: a level 8 snowflake does have 196,608 segments, after all.

Here's the C# code with the modified engine and the algorithm for creating Koch snowflakes:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Colors;

using System;

namespace TurtleGraphics

{

  // This class encapsulates pen

  // information and will be

  // used by our TurtleEngine

  class Pen

  {

    // Private members

    private Color m_color;

    private double m_width;

    private bool m_down;

    // Public properties

    public Color Color

    {

      get { return m_color; }

      set { m_color = value; }

    }

    public double Width

    {

      get { return m_width; }

      set { m_width = value; }

    }

    public bool Down

    {

      get { return m_down; }

      set { m_down = value; }

    }

    // Constructor

    public Pen()

    {

      m_color =

        Color.FromColorIndex(ColorMethod.ByAci, 0);

      m_width = 0.0;

      m_down = false;

    }

  }

  // The main Turtle Graphics engine

  class TurtleEngine

  {

    // Private members

    private Transaction m_trans;

    private Polyline m_poly;

    private Pen m_pen;

    private Point3d m_position;

    private Vector3d m_direction;

    private bool m_updateGraphics;

    // Public properties

    public Point3d Position

    {

      get { return m_position; }

      set { m_position = value; }

    }

    public Vector3d Direction

    {

      get { return m_direction; }

      set { m_direction = value; }

    }

    // Constructor

    public TurtleEngine(Transaction tr)

    {

      m_pen = new Pen();

      m_trans = tr;

      m_poly = null;

      m_position = Point3d.Origin;

      m_direction = new Vector3d(1.0, 0.0, 0.0);

      m_updateGraphics = false;

    }

    // Public methods

    public void Turn(double angle)

    {

      // Rotate our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          Vector3d.ZAxis,

          Position

        );

      Direction =

        Direction.TransformBy(mat);

    }

    public void Move(double distance)

    {

      // Move the cursor by a specified

      // distance in the direction in

      // which we're pointing

      Point3d oldPos = Position;

      Position += Direction * distance;

      // If the pen is down, we draw something

      if (m_pen.Down)

        GenerateSegment(oldPos, Position);

    }

    public void PenDown()

    {

      m_pen.Down = true;

    }

    public void PenUp()

    {

      m_pen.Down = false;

      // We'll start a new entity with the

      // next use of the pen

      m_poly = null;

    }

    public void SetPenWidth(double width)

    {

      m_pen.Width = width;

    }

    public void SetPenColor(int idx)

    {

      // Right now we just use an ACI,

      // to make the code simpler

      Color col =

        Color.FromColorIndex(

          ColorMethod.ByAci,

          (short)idx

        );

      // If we have to change the color,

      // we'll start a new entity

      // (if the entity type we're creating

      // supports per-segment colors, we

      // don't need to do this)

      if (col != m_pen.Color)

      {

        m_poly = null;

        m_pen.Color = col;

      }

    }

    // Internal helper to generate geometry

    // (this could be optimised to keep the

    // object we're generating open, rather

    // than having to reopen it each time)

    private void GenerateSegment(

      Point3d oldPos, Point3d newPos)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Autodesk.AutoCAD.ApplicationServices.

      TransactionManager tm =

        doc.TransactionManager;

      Plane plane;

      // Create the current object, if there is none

      if (m_poly == null)

      {

        BlockTable bt =

          (BlockTable)m_trans.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

        BlockTableRecord ms =

          (BlockTableRecord)m_trans.GetObject(

            bt[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite

          );

        // Create the polyline

        m_poly = new Polyline();

        m_poly.Color = m_pen.Color;

        // Define its plane

        plane = new Plane(

          m_poly.Ecs.CoordinateSystem3d.Origin,

          m_poly.Ecs.CoordinateSystem3d.Zaxis

        );

        // Add the first vertex

        m_poly.AddVertexAt(

          0, oldPos.Convert2d(plane),

          0.0, m_pen.Width, m_pen.Width

        );

        // Add the polyline to the database

        ms.AppendEntity(m_poly);

        m_trans.AddNewlyCreatedDBObject(m_poly, true);

      }

      else

      {

        // Calculate its plane

        plane = new Plane(

          m_poly.Ecs.CoordinateSystem3d.Origin,

          m_poly.Ecs.CoordinateSystem3d.Zaxis

        );

      }

      // Now we have our current object open,

      // add the new vertex

      m_poly.AddVertexAt(

        m_poly.NumberOfVertices,

        newPos.Convert2d(plane),

        0.0, m_pen.Width, m_pen.Width

      );

      // Display the graphics, to avoid long,

      // black-box operations

      if (m_updateGraphics)

      {

        tm.QueueForGraphicsFlush();

        tm.FlushGraphics();

        ed.UpdateScreen();

      }

    }

  }

  public class Commands

  {

    static void KochIsland(

      TurtleEngine te,

      double size,

      int level

    )

    {

      for (int i = 0; i < 3; i++)

      {

        // Draw a side

        KSide(te, size, level);

        // Turn 120 degrees to the left

        te.Turn(2 * Math.PI / 3);

      }

    }

    static void KSide(

      TurtleEngine te,

      double size,

      int level

    )

    {

      // When at level 0, draw the side and exit

      if (level == 0)

        te.Move(size);

      else

      {

        // Else recurse for each segment of the side

        KSide(te, size / 3, level - 1);

        te.Turn(Math.PI / -3);

        KSide(te, size / 3, level - 1);

        te.Turn(2 * Math.PI / 3);

        KSide(te, size / 3, level - 1);

        te.Turn(Math.PI / -3);

        KSide(te, size / 3, level - 1);

      }

    }

    [CommandMethod("KSF")]

    static public void KochSnowFlake()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      // Ask for the recursion level

      int level = 6;

      PromptIntegerOptions pio =

        new PromptIntegerOptions(

          "\nEnter recursion level <6>: "

        );

      pio.AllowNone = true;

      pio.LowerLimit = 0;

      pio.UpperLimit = 8;

      PromptIntegerResult pir =

        ed.GetInteger(pio);

      if (pir.Status != PromptStatus.OK &&

          pir.Status != PromptStatus.None)

        return;

      if (pir.Status == PromptStatus.OK)

        level = pir.Value;

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        TurtleEngine te = new TurtleEngine(tr);

        // Draw a Koch snowflake

        te.SetPenColor(0);

        te.SetPenWidth(0);

        te.PenDown();

        // 100 is an arbitrary value:

        // you could also prompt the user for this

        KochIsland(te, 100, level);

        tr.Commit();

      }

    }

  }

}

Here are the results of the KSF command, when used to generate a level 6 snowflake. Although frankly you wouldn't see a difference between a level 5 and a level 10 snowflake at this resolution. :-)

Next time we'll look at some recursive code to generate less precise, more natural forms.

A simple turtle graphics implementation in AutoCAD using .NET

Like many thirty-something Brits (and possible non-Brits, for all I know) my earliest introduction to the world of graphics programming was via a language called Logo running on the BBC Microcomputer.

This machine and its educational software were commonplace in UK schools in the 1980s, and I have clear memories of staying late at primary school (which I suppose means I was somewhere between 8 and 10) to fool around with BBC BASIC. With a friend I used to try to write text-based adventures ("you are in a cave, there are exits North, South, East and West" - you know the kind of thing) which we padded with loads and loads of comments to stop them from loading embarrassingly quickly from tape. Oh, the memories. :-)

Anyway, I digress. Logo provided a really great introduction to vector graphics: even as we were being taught trigonometry we were exposed to an environment that allowed us to translate these concepts into graphics on a computer screen. Too cool.

Thinking back about all this, I decided to implement a simple turtle graphics engine inside AutoCAD, to allow eventual integration of a Logo-like language into it. The idea was this: to implement an engine exposing a series of methods (Move(), Turn(), PenUp(), PenDown(), SetPenColor() and SetPenWidth(), to start with) that could be used to implement a subset of the Logo language. I decided to write the engine in C#, whose object-orientation makes it well-suited to this type of task, and then look into using F# for implementing the language to drive it in a future post.

F# is very good for implementing new or existing programming languages: the whole area of Domain Specific Languages (DSLs) is a major selling point for functional languages, generally. They're very well-suited to the tasks that make up the interpretation/compilation process: lexical analysis, syntactic analysis, etc., as much of the hard work is around tokenizing strings, processing lists and mapping behaviours (and these activities are most functional programming languages' "bread and butter").

Only after deciding this approach did I stumble across an existing Logo implementation in F#, so it appears that integrating the Logo language may prove simpler than I expected.

A little more on the implementation of the turtle graphics engine: I decided to implement a 2D system, to start with, generating geometry as a series of Polyline objects. Every time the PenUp() function is called we tell the system to create a new object. We also do this for SetPenColor() in the cases where the colour is changed, as Polylines do not support per-segment colours (if we were to implement a custom object that did so, we could change the implementation to keep contiguous, multi-coloured segments in a single object). The current implementation reopens the previous object each time, and therefore creates a new transaction for every single Move() operation. This is clearly sub-optimal, but I quite like the old-school effect of watching the graphics get revealed segment by segment. :-) A more optimal technique would be to keep the object open while the pen is down and the engine is in use, and this is currently left as an exercise for the reader (or until I hit a use case where I can no longer be bothered to wait for the execution to complete :-).

It would be quite simple to take this engine into 3D, and I may well do so at some point in the future. There seem to be a number of successful 3D Logo implementations out there, and they really have great potential when generating organic models, as you can see from this page. Languages such as Logo can be applied very effectively to the task of generating fractal geometry by interpreting (and implementing) Lindenmayer (or L-) systems, for instance.

OK, enough background information... here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Colors;

using System;

namespace TurtleGraphics

{

  // This class encapsulates pen

  // information and will be

  // used by our TurtleEngine

  class Pen

  {

    // Private members

    private Color m_color;

    private double m_width;

    private bool m_down;

    // Public properties

    public Color Color

    {

      get { return m_color; }

      set { m_color = value; }

    }

    public double Width

    {

      get { return m_width; }

      set { m_width = value; }

    }

    public bool Down

    {

      get { return m_down; }

      set { m_down = value; }

    }

    // Constructor

    public Pen()

    {

      m_color =

        Color.FromColorIndex(ColorMethod.ByAci, 0);

      m_width = 0.0;

      m_down = false;

    }

  }

  // The main Turtle Graphics engine

  class TurtleEngine

  {

    // Private members

    private ObjectId m_currentObject;

    private Pen m_pen;

    private Point3d m_position;

    private Vector3d m_direction;

    // Public properties

    public Point3d Position

    {

      get { return m_position; }

      set { m_position = value; }

    }

    public Vector3d Direction

    {

      get { return m_direction; }

      set { m_direction = value; }

    }

    // Constructor

    public TurtleEngine()

    {

      m_pen = new Pen();

      m_currentObject = ObjectId.Null;

      m_position = Point3d.Origin;

      m_direction = new Vector3d(1.0, 0.0, 0.0);

    }

    // Public methods

    public void Turn(double angle)

    {

      // Rotate our direction by the

      // specified angle

      Matrix3d mat =

        Matrix3d.Rotation(

          angle,

          Vector3d.ZAxis,

          Position

        );

      Direction =

        Direction.TransformBy(mat);

    }

    public void Move(double distance)

    {

      // Move the cursor by a specified

      // distance in the direction in

      // which we're pointing

      Point3d oldPos = Position;

      Position += Direction * distance;

      // If the pen is down, we draw something

      if (m_pen.Down)

        GenerateSegment(oldPos, Position);

    }

    public void PenDown()

    {

      m_pen.Down = true;

    }

    public void PenUp()

    {

      m_pen.Down = false;

      // We'll start a new entity with the next

      // use of the pen

      m_currentObject =

        ObjectId.Null;

    }

    public void SetPenWidth(double width)

    {

      m_pen.Width = width;

    }

    public void SetPenColor(int idx)

    {

      // Right now we just use an ACI,

      // to make the code simpler

      Color col =

        Color.FromColorIndex(

          ColorMethod.ByAci,

          (short)idx

        );

      // If we have to change the color,

      // we'll start a new entity

      // (if the entity type we're creating

      // supports per-segment colors, we

      // don't need to do this)

      if (col != m_pen.Color)

      {

        m_currentObject =

          ObjectId.Null;

        m_pen.Color = col;

      }

    }

    // Internal helper to generate geometry

    // (this could be optimised to keep the

    // object we're generating open, rather

    // than having to reopen it each time)

    private void GenerateSegment(

      Point3d oldPos, Point3d newPos)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      Autodesk.AutoCAD.ApplicationServices.

      TransactionManager tm =

        doc.TransactionManager;

      Transaction tr =

        tm.StartTransaction();

      using (tr)

      {

        Polyline pl;

        Plane plane;

        // Create the current object, if there is none

        if (m_currentObject == ObjectId.Null)

        {

          BlockTable bt =

            (BlockTable)tr.GetObject(

              db.BlockTableId,

              OpenMode.ForRead

            );

          BlockTableRecord ms =

            (BlockTableRecord)tr.GetObject(

              bt[BlockTableRecord.ModelSpace],

              OpenMode.ForWrite

            );

          // Create the polyline

          pl = new Polyline();

          pl.Color = m_pen.Color;

          // Define its plane

          plane = new Plane(

            pl.Ecs.CoordinateSystem3d.Origin,

            pl.Ecs.CoordinateSystem3d.Zaxis

          );

          // Add the first vertex

          pl.AddVertexAt(

            0, oldPos.Convert2d(plane),

            0.0, m_pen.Width, m_pen.Width

          );

          // Add the polyline to the database

          m_currentObject =

            ms.AppendEntity(pl);

          tr.AddNewlyCreatedDBObject(pl, true);

        }

        else

        {

          // Get the current object, if there is one

          pl =

            (Polyline)tr.GetObject(

              m_currentObject,

              OpenMode.ForWrite

            );

          // Calculate its plane

          plane = new Plane(

            pl.Ecs.CoordinateSystem3d.Origin,

            pl.Ecs.CoordinateSystem3d.Zaxis

          );

        }

        // Now we have our current object open,

        // add the new vertex

        pl.AddVertexAt(

          pl.NumberOfVertices,

          newPos.Convert2d(plane),

          0.0, m_pen.Width, m_pen.Width

        );

        // Display the graphics, to avoid long,

        // black-box operations

        tm.QueueForGraphicsFlush();

        tm.FlushGraphics();

        ed.UpdateScreen();

        tr.Commit();

      }

    }

  }

  public class Commands

  {

    // A command to create some simple geometry

    [CommandMethod("DTG")]

    static public void DrawTurtleGraphics()

    {

      TurtleEngine te = new TurtleEngine();

      // Draw a red circle

      te.SetPenColor(1);

      te.SetPenWidth(7);

      te.PenDown();

      for (int i = 0; i < 360; i++)

      {

        te.Move(2);

        te.Turn(Math.PI / 180);

      }

      // Move to the next space

      te.PenUp();

      te.Move(200);

      // Draw a green square

      te.SetPenColor(3);

      te.SetPenWidth(5);

      te.PenDown();

      for (int i = 0; i < 4; i++)

      {

        te.Move(230);

        te.Turn(Math.PI / 2);

      }

      // Move to the next space

      te.PenUp();

      te.Move(300);

      // Draw a blue triangle

      te.SetPenColor(5);

      te.SetPenWidth(3);

      te.PenDown();

      for (int i = 0; i < 3; i++)

      {

        te.Move(266);

        te.Turn(2 * Math.PI / 3);

      }

      // Move to the next space

      te.PenUp();

      te.Move(400);

      te.Turn(Math.PI / 2);

      te.Move(115);

      te.Turn(Math.PI / -2);

      // Draw a multi-colored, spirograph-like shape

      te.SetPenWidth(1);

      te.PenDown();

      for (int i = 0; i < 36; i++)

      {

        te.Turn(Math.PI / 18);

        te.SetPenColor(i);

        for (int j = 0; j < 360; j++)

        {

          te.Move(1);

          te.Turn(Math.PI / 180);

        }

      }

    }

  }

}

Here are the results of running the DTG command, which simply calls into the TurtleEngine to test out its capabilities, creating a series of shapes of different pen colours and widths:

The first three objects are single objects, but are multi-segment polylines (don't expect the engine to generate circles, for instance: most turtle graphics code to generate circles actually create objects with 360 segments). The fourth object is a series of 36 circles: as mentioned earlier, Polyline objects do not support per-segment colours, but if this was all a uniform colour (by commenting out the call to te.SetPenColor(i)), it would all be a single Polyline with 36 * 360 segments.

A handy .NET class to help manage long operations in AutoCAD

This post was almost called "Generating Koch fractals in AutoCAD using .NET - Part 3", following on from Parts 1 & 2 of the series. But by the time I'd completed the code, I realised it to be of more general appeal and decided to provide it with a more representative title.

I started off by adding a progress meter and an escape key handler to the code in the last post. Then, while refactoring the code, I decided to encapsulate the functionality in a standalone class that could be dropped into pretty much any AutoCAD .NET project (although I've implemented it in C#, as usual).

So what we have is a new class called LongOperationManager, which does the following:

• Displays and updates a progress meter (at the bottom left of AutoCAD's window)
  • Allowing you to set an arbitrary message and total number of operations
• Listens for "escape" in case the user wants to interrupt the current operation

Here's the class implementation:

public class LongOperationManager :

  IDisposable, System.Windows.Forms.IMessageFilter

{

  // The message code corresponding to a keypress

  const int WM_KEYDOWN = 0x0100;

  // The number of times to update the progress meter

  // (for some reason you need 600 to tick through

  //  for each percent)

  const int progressMeterIncrements = 600;

  // Internal members for metering progress

  private ProgressMeter pm;

  private long updateIncrement;

  private long currentInc;

  // External flag for checking cancelled status

  public bool cancelled = false;

  // Constructor

  public LongOperationManager(string message)

  {

    System.Windows.Forms.Application.

      AddMessageFilter(this);

    pm = new ProgressMeter();

    pm.Start(message);

    pm.SetLimit(progressMeterIncrements);

    currentInc = 0;

  }

  // System.IDisposable.Dispose

  public void Dispose()

  {

    pm.Stop();

    pm.Dispose();

    System.Windows.Forms.Application.

      RemoveMessageFilter(this);

  }

  // Set the total number of operations

  public void SetTotalOperations(long totalOps)

  {

    // We really just care about when we need

    // to update the timer

    updateIncrement =

      (totalOps > progressMeterIncrements ?

        totalOps / progressMeterIncrements :

        totalOps

      );

  }

  // This function is called whenever an operation

  // is performed

  public bool Tick()

  {

    if (++currentInc == updateIncrement)

    {

      pm.MeterProgress();

      currentInc = 0;

      System.Windows.Forms.Application.DoEvents();

    }

    // Check whether the filter has set the flag

    if (cancelled)

      pm.Stop();

    return !cancelled;

  }

  // The message filter callback

  public bool PreFilterMessage(

    ref System.Windows.Forms.Message m

  )

  {

    if (m.Msg == WM_KEYDOWN)

    {

      // Check for the Escape keypress

      System.Windows.Forms.Keys kc =

        (System.Windows.Forms.Keys)(int)m.WParam &

        System.Windows.Forms.Keys.KeyCode;

      if (m.Msg == WM_KEYDOWN &&

          kc == System.Windows.Forms.Keys.Escape)

      {

        cancelled = true;

      }

      // Return true to filter all keypresses

      return true;

    }

    // Return false to let other messages through

    return false;

  }

}

In terms of how to use the class... first of all you create an instance of it, setting the string to be shown on the progress meter (just like AutoCAD's ProgressMeter class). As the LongOperationManager implements IDisposable, then at the end you should either call Dispose or manage it's scope with the using() statement.

I chose to separate the setting of the total number of operations to be completed from the object's construction, as in our example we need to an initial pass before we know how many objects we're working with (and we want to at least put the label on the progress meter while we perform that initial pass).

Then we just call the Tick() method whenever we perform an operation - this updates the progress meter and checks for use of the escape key. The idea is that you set the total number of operations and then call Tick() for each one of those individual operations - the class takes care of how often it needs to update the progress meter. If it finds escape has been used, the Tick() method will return false.

That's about it, aside from the fact you can also query the "cancelled" property to see whether escape has been used.

Here's the basic approach:

LongOperationManager lom =

  new LongOperationManager("Fractalizing entities");

using (lom)

{

  ...

  lom.SetTotalOperations(totalOps);

  ...

  while (true)

  {

    ...

    if (!lom.Tick())

    {

      ed.WriteMessage("\nFractalization cancelled.\n");

      break;

    }

  }

}

Here's the code integrated into the previous example, with the significant lines in red:

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.DatabaseServices;

    3 using Autodesk.AutoCAD.EditorInput;

    4 using Autodesk.AutoCAD.Runtime;

    5 using Autodesk.AutoCAD.Geometry;

    6 using System.Collections.Generic;

    7 using System;

    8

    9 namespace Kochizer

   10 {

   11   public class Commands

   12   {

   13     // We generate 4 new entities for every old entity

   14     // (unless a complex entity such as a polyline)

   15

   16     const int newEntsPerOldEnt = 4;

   17

   18     [CommandMethod("KA")]

   19     public void KochizeAll()

   20     {

   21       Document doc =

   22         Application.DocumentManager.MdiActiveDocument;

   23       Database db = doc.Database;

   24       Editor ed = doc.Editor;

   25

   26       // Acquire user input - whether to create the

   27       // new geometry to the left or the right...

   28

   29       PromptKeywordOptions pko =

   30         new PromptKeywordOptions(

   31           "\nCreate fractal to side (Left/<Right>): "

   32         );

   33       pko.Keywords.Add("Left");

   34       pko.Keywords.Add("Right");

   35

   36       PromptResult pr =

   37         ed.GetKeywords(pko);

   38       bool bLeft = false;

   39

   40       if (pr.Status != PromptStatus.None &&

   41           pr.Status != PromptStatus.OK)

   42         return;

   43

   44       if ((string)pr.StringResult == "Left")

   45         bLeft = true;

   46

   47       // ... and the recursion depth for the command.

   48

   49       PromptIntegerOptions pio =

   50         new PromptIntegerOptions(

   51           "\nEnter recursion level <1>: "

   52         );

   53       pio.AllowZero = false;

   54       pio.AllowNegative = false;

   55       pio.AllowNone = true;

   56

   57       PromptIntegerResult pir =

   58         ed.GetInteger(pio);

   59       int recursionLevel = 1;

   60

   61       if (pir.Status != PromptStatus.None &&

   62           pir.Status != PromptStatus.OK)

   63         return;

   64

   65       if (pir.Status == PromptStatus.OK)

   66         recursionLevel = pir.Value;

   67

   68       // Create and add our long operation handler

   69       LongOperationManager lom =

   70         new LongOperationManager("Fractalizing entities");

   71

   72       using (lom)

   73       {

   74         // Note: strictly speaking we're not recursing,

   75         // we're iterating, but the effect to the user

   76         // is the same.

   77

   78         Transaction tr =

   79           doc.TransactionManager.StartTransaction();

   80         using (tr)

   81         {

   82           BlockTable bt =

   83             (BlockTable)tr.GetObject(

   84               db.BlockTableId,

   85               OpenMode.ForRead

   86             );

   87           using (bt)

   88           {

   89             // No need to open the block table record

   90             // for write, as we're just reading data

   91             // for now

   92

   93             BlockTableRecord btr =

   94               (BlockTableRecord)tr.GetObject(

   95                 bt[BlockTableRecord.ModelSpace],

   96                 OpenMode.ForRead

   97               );

   98             using (btr)

   99             {

  100               // List of changed entities

  101               // (will contain complex entities, such as

  102               // polylines"

  103

  104               ObjectIdCollection modified =

  105                 new ObjectIdCollection();

  106

  107               // List of entities to erase

  108               // (will contain replaced entities)

  109

  110               ObjectIdCollection toErase =

  111                 new ObjectIdCollection();

  112

  113               // List of new entitites to add

  114               // (will be processed recursively or

  115               // assed to the open block table record)

  116

  117               List<Entity> newEntities =

  118                 new List<Entity>(

  119                   db.ApproxNumObjects * newEntsPerOldEnt

  120                 );

  121

  122               // Kochize each entity in the open block

  123               // table record

  124

  125               foreach (ObjectId objId in btr)

  126               {

  127                 Entity ent =

  128                   (Entity)tr.GetObject(

  129                     objId,

  130                     OpenMode.ForRead

  131                   );

  132                 Kochize(

  133                   ent,

  134                   modified,

  135                   toErase,

  136                   newEntities,

  137                   bLeft

  138                 );

  139               }

  140

  141               // The number of operations is...

  142               //  The number of complex entities multiplied

  143               //  by the recursion level (they each get

  144               //  "kochized" once per level,

  145               //  even if that's a long operation)

  146               // plus

  147               //  (4^0 + 4^1 + 4^2 + 4^3... + 4^n) multiplied

  148               //  by the number of db-resident ents

  149               // where n is the recursion level. Phew!

  150

  151               long totalOps =

  152                     modified.Count * recursionLevel +

  153                     operationCount(recursionLevel) *

  154                     toErase.Count;

  155               lom.SetTotalOperations(totalOps);

  156

  157               // If we need to loop,

  158               // work on the returned entities

  159

  160               while (--recursionLevel > 0)

  161               {

  162                 // Create an output array

  163

  164                 List<Entity> newerEntities =

  165                   new List<Entity>(

  166                     newEntities.Count * newEntsPerOldEnt

  167                   );

  168

  169                 // Kochize all the modified (complex) ents

  170

  171                 foreach (ObjectId objId in modified)

  172                 {

  173                   if (!lom.Tick())

  174                   {

  175                     ed.WriteMessage(

  176                       "\nFractalization cancelled.\n"

  177                     );

  178                     break;

  179                   }

  180

  181                   Entity ent =

  182                     (Entity)tr.GetObject(

  183                       objId,

  184                       OpenMode.ForRead

  185                     );

  186                   Kochize(

  187                     ent,

  188                     modified,

  189                     toErase,

  190                     newerEntities,

  191                     bLeft

  192                   );

  193                 }

  194

  195                 // Kochize all the non-db resident entities

  196                 if (!lom.cancelled)

  197                 {

  198                   foreach (Entity ent in newEntities)

  199                   {

  200                     if (!lom.Tick())

  201                     {

  202                       ed.WriteMessage(

  203                         "\nFractalization cancelled.\n"

  204                       );

  205                       break;

  206                     }

  207                     Kochize(

  208                       ent,

  209                       modified,

  210                       toErase,

  211                       newerEntities,

  212                       bLeft

  213                     );

  214                   }

  215                 }

  216

  217                 // We now longer need the intermediate ents

  218                 // previously output for the level above,

  219                 // we replace them with the latest output

  220

  221                 newEntities.Clear();

  222                 newEntities = newerEntities;

  223               }

  224

  225               lom.Tick();

  226

  227               if (!lom.cancelled)

  228               {

  229                 // Erase each replaced db-resident ent

  230

  231                 foreach (ObjectId objId in toErase)

  232                 {

  233                   Entity ent =

  234                     (Entity)tr.GetObject(

  235                       objId,

  236                       OpenMode.ForWrite

  237                     );

  238                   ent.Erase();

  239                 }

  240

  241                 // Add the new entities

  242

  243                 btr.UpgradeOpen();

  244                 foreach (Entity ent in newEntities)

  245                 {

  246                   btr.AppendEntity(ent);

  247                   tr.AddNewlyCreatedDBObject(ent, true);

  248                 }

  249               }

  250               tr.Commit();

  251             }

  252           }

  253         }

  254       }

  255     }

  256

  257     static long

  258     operationCount(int nRecurse)

  259     {

  260       if (1 >= nRecurse)

  261         return 1;

  262       return

  263         (long)Math.Pow(

  264           newEntsPerOldEnt,

  265           nRecurse - 1

  266         )

  267         + operationCount(nRecurse - 1);

  268     }

  269

  270     // Dispatch function to call through to various per-type

  271     // functions

  272

  273     private void Kochize(

  274       Entity ent,

  275       ObjectIdCollection modified,

  276       ObjectIdCollection toErase,

  277       List<Entity> toAdd,

  278       bool bLeft

  279     )

  280     {

  281       Line ln = ent as Line;

  282       if (ln != null)

  283       {

  284         Kochize(ln, modified, toErase, toAdd, bLeft);

  285         return;

  286       }

  287       Arc arc = ent as Arc;

  288       if (arc != null)

  289       {

  290         Kochize(arc, modified, toErase, toAdd, bLeft);

  291         return;

  292       }

  293       Polyline pl = ent as Polyline;

  294       if (pl != null)

  295       {

  296         Kochize(pl, modified, toErase, toAdd, bLeft);

  297         return;

  298       }

  299     }

  300

  301     // Create 4 new lines from a line passed in

  302

  303     private void Kochize(

  304       Line ln,

  305       ObjectIdCollection modified,

  306       ObjectIdCollection toErase,

  307       List<Entity> toAdd,

  308       bool bLeft

  309     )

  310     {

  311       // Get general info about the line

  312       // and calculate the main 5 points

  313

  314       Point3d pt1 = ln.StartPoint,

  315               pt5 = ln.EndPoint;

  316       Vector3d vec1 = pt5 - pt1,

  317               norm1 = vec1.GetNormal();

  318       double d_3 = vec1.Length / 3;

  319       Point3d pt2 = pt1 + (norm1 * d_3),

  320               pt4 = pt1 + (2 * norm1 * d_3);

  321       Vector3d vec2 = pt4 - pt2;

  322

  323       if (bLeft)

  324         vec2 =

  325           vec2.RotateBy(

  326             Math.PI / 3, new Vector3d(0, 0, 1)

  327           );

  328       else

  329         vec2 =

  330           vec2.RotateBy(

  331             5 * Math.PI / 3, new Vector3d(0, 0, 1)

  332           );

  333       Point3d pt3 = pt2 + vec2;

  334

  335       // Mark the original to be erased

  336

  337       if (ln.ObjectId != ObjectId.Null)

  338         toErase.Add(ln.ObjectId);

  339

  340       // Create the first line

  341

  342       Line ln1 = new Line(pt1, pt2);

  343       ln1.SetPropertiesFrom(ln);

  344       ln1.Thickness = ln.Thickness;

  345       toAdd.Add(ln1);

  346

  347       // Create the second line

  348

  349       Line ln2 = new Line(pt2, pt3);

  350       ln2.SetPropertiesFrom(ln);

  351       ln2.Thickness = ln.Thickness;

  352       toAdd.Add(ln2);

  353

  354       // Create the third line

  355

  356       Line ln3 = new Line(pt3, pt4);

  357       ln3.SetPropertiesFrom(ln);

  358       ln3.Thickness = ln.Thickness;

  359       toAdd.Add(ln3);

  360

  361       // Create the fourth line

  362

  363       Line ln4 = new Line(pt4, pt5);

  364       ln4.SetPropertiesFrom(ln);

  365       ln4.Thickness = ln.Thickness;

  366       toAdd.Add(ln4);

  367     }

  368

  369     // Create 4 new arcs from an arc passed in

  370

  371     private void Kochize(

  372       Arc arc,

  373       ObjectIdCollection modified,

  374       ObjectIdCollection toErase,

  375       List<Entity> toAdd,

  376       bool bLeft

  377     )

  378     {

  379       // Get general info about the arc

  380       // and calculate the main 5 points

  381

  382       Point3d pt1 = arc.StartPoint,

  383               pt5 = arc.EndPoint;

  384       double length = arc.GetDistAtPoint(pt5),

  385             angle = arc.StartAngle;

  386       Vector3d full = pt5 - pt1;

  387

  388       Point3d pt2 = arc.GetPointAtDist(length / 3),

  389               pt4 = arc.GetPointAtDist(2 * length / 3);

  390

  391       // Mark the original to be erased

  392

  393       if (arc.ObjectId != ObjectId.Null)

  394         toErase.Add(arc.ObjectId);

  395

  396       // Create the first arc

  397

  398       Point3d mid = arc.GetPointAtDist(length / 6);

  399       CircularArc3d tmpArc =

  400         new CircularArc3d(pt1, mid, pt2);

  401       Arc arc1 = circArc2Arc(tmpArc);

  402       arc1.SetPropertiesFrom(arc);

  403       arc1.Thickness = arc.Thickness;

  404       toAdd.Add(arc1);

  405

  406       // Create the second arc

  407

  408       mid = arc.GetPointAtDist(length / 2);

  409       tmpArc.Set(pt2, mid, pt4);

  410       if (bLeft)

  411         tmpArc.RotateBy(Math.PI / 3, tmpArc.Normal, pt2);

  412       else

  413         tmpArc.RotateBy(5 * Math.PI / 3, tmpArc.Normal, pt2);

  414       Arc arc2 = circArc2Arc(tmpArc);

  415       arc2.SetPropertiesFrom(arc);

  416       arc2.Thickness = arc.Thickness;

  417       toAdd.Add(arc2);

  418

  419       // Create the third arc

  420

  421       tmpArc.Set(pt2, mid, pt4);

  422       if (bLeft)

  423         tmpArc.RotateBy(5 * Math.PI / 3, tmpArc.Normal, pt4);

  424       else

  425         tmpArc.RotateBy(Math.PI / 3, tmpArc.Normal, pt4);

  426       Arc arc3 = circArc2Arc(tmpArc);

  427       arc3.SetPropertiesFrom(arc);

  428       arc3.Thickness = arc.Thickness;

  429       toAdd.Add(arc3);

  430

  431       // Create the fourth arc

  432

  433       mid = arc.GetPointAtDist(5 * length / 6);

  434       Arc arc4 =

  435         circArc2Arc(new CircularArc3d(pt4, mid, pt5));

  436       arc4.SetPropertiesFrom(arc);

  437       arc4.Thickness = arc.Thickness;

  438       toAdd.Add(arc4);

  439     }

  440

  441     Arc circArc2Arc(CircularArc3d circArc)

  442     {

  443       Point3d center = circArc.Center;

  444       Vector3d normal = circArc.Normal;

  445       Vector3d refVec = circArc.ReferenceVector;

  446       Plane plane = new Plane(center, normal);

  447       double ang = refVec.AngleOnPlane(plane);

  448       return new Arc(

  449         center,

  450         normal,

  451         circArc.Radius,

  452         circArc.StartAngle + ang,

  453         circArc.EndAngle + ang

  454       );

  455     }

  456

  457     private void Kochize(

  458       Polyline pl,

  459       ObjectIdCollection modified,

  460       ObjectIdCollection toErase,

  461       List<Entity> toAdd,

  462       bool bLeft

  463     )

  464     {

  465       pl.UpgradeOpen();

  466

  467       if (pl.ObjectId != ObjectId.Null &&

  468           !modified.Contains(pl.ObjectId))

  469       {

  470         modified.Add(pl.ObjectId);

  471       }

  472

  473       for(int vn = 0; vn < pl.NumberOfVertices; vn++)

  474       {

  475         SegmentType st = pl.GetSegmentType(vn);

  476         if (st != SegmentType.Line && st != SegmentType.Arc)

  477           continue;

  478

  479         double sw = pl.GetStartWidthAt(vn),

  480               ew = pl.GetEndWidthAt(vn);

  481

  482         if (st == SegmentType.Line)

  483         {

  484           if (vn + 1 == pl.NumberOfVertices)

  485             continue;

  486

  487           LineSegment2d ls = pl.GetLineSegment2dAt(vn);

  488           Point2d pt1 = ls.StartPoint,

  489                   pt5 = ls.EndPoint;

  490           Vector2d vec = pt5 - pt1;

  491           double d_3 = vec.Length / 3;

  492           Point2d pt2 = pt1 + (vec.GetNormal() * d_3),

  493                   pt4 = pt1 + (vec.GetNormal() * 2 * d_3);

  494           Vector2d vec2 = pt4 - pt2;

  495

  496           if (bLeft)

  497             vec2 = vec2.RotateBy(Math.PI / 3);

  498           else

  499             vec2 = vec2.RotateBy(5 * Math.PI / 3);

  500

  501           Point2d pt3 = pt2 + vec2;

  502

  503           pl.AddVertexAt(++vn, pt2, 0, sw, ew);

  504           pl.AddVertexAt(++vn, pt3, 0, sw, ew);

  505           pl.AddVertexAt(++vn, pt4, 0, sw, ew);

  506         }

  507         else if (st == SegmentType.Arc)

  508         {

  509           CircularArc3d ca = pl.GetArcSegmentAt(vn);

  510           double oldBulge = pl.GetBulgeAt(vn);

  511

  512           // Build a standard arc and use that for the calcs

  513

  514           Arc arc = circArc2Arc(ca);

  515

  516           // Get the main 5 points

  517

  518           Point3d pt1 = arc.StartPoint,

  519                   pt5 = arc.EndPoint;

  520

  521           double ln = arc.GetDistAtPoint(pt5);

  522           Point3d pt2 = arc.GetPointAtDist(ln / 3),

  523                   pt4 = arc.GetPointAtDist(2 * ln / 3);

  524

  525           Point3d mid = arc.GetPointAtDist(ln / 2);

  526

  527           CircularArc3d tmpArc =

  528             new CircularArc3d(pt2, mid, pt4);

  529           if (bLeft)

  530             tmpArc.RotateBy(5*Math.PI/3, tmpArc.Normal, pt4);

  531           else

  532             tmpArc.RotateBy(Math.PI / 3, tmpArc.Normal, pt4);

  533

  534           Point3d pt3 = tmpArc.StartPoint;

  535

  536           // Now add the new segments, setting the bulge

  537           // for the existing one and the new ones to a third

  538           // (as the segs are a third as big as the old one)

  539

  540           CoordinateSystem3d ecs = pl.Ecs.CoordinateSystem3d;

  541           Plane pn = new Plane(ecs.Origin, pl.Normal);

  542           double bu = oldBulge / 3;

  543

  544           pl.SetBulgeAt(vn, bu);

  545           pl.AddVertexAt(

  546             ++vn, pt2.Convert2d(pn), bu, sw, ew);

  547           pl.AddVertexAt(

  548             ++vn, pt3.Convert2d(pn), bu, sw, ew);

  549           pl.AddVertexAt(

  550             ++vn, pt4.Convert2d(pn), bu, sw, ew);

  551         }

  552       }

  553       pl.DowngradeOpen();

  554     }

  555

  556     public class LongOperationManager :

  557       IDisposable, System.Windows.Forms.IMessageFilter

  558     {

  559       // The message code corresponding to a keypress

  560       const int WM_KEYDOWN = 0x0100;

  561

  562       // The number of times to update the progress meter

  563       // (for some reason you need 600 to tick through

  564       //  for each percent)

  565       const int progressMeterIncrements = 600;

  566

  567       // Internal members for metering progress

  568       private ProgressMeter pm;

  569       private long updateIncrement;

  570       private long currentInc;

  571

  572       // External flag for checking cancelled status

  573       public bool cancelled = false;

  574

  575       // Constructor

  576

  577       public LongOperationManager(string message)

  578       {

  579         System.Windows.Forms.Application.

  580           AddMessageFilter(this);

  581         pm = new ProgressMeter();

  582         pm.Start(message);

  583         pm.SetLimit(progressMeterIncrements);

  584         currentInc = 0;

  585       }

  586

  587       // System.IDisposable.Dispose

  588

  589       public void Dispose()

  590       {

  591         pm.Stop();

  592         pm.Dispose();

  593         System.Windows.Forms.Application.

  594           RemoveMessageFilter(this);

  595       }

  596

  597       // Set the total number of operations

  598

  599       public void SetTotalOperations(long totalOps)

  600       {

  601         // We really just care about when we need

  602         // to update the timer

  603         updateIncrement =

  604           (totalOps > progressMeterIncrements ?

  605             totalOps / progressMeterIncrements :

  606             totalOps

  607           );

  608       }

  609

  610       // This function is called whenever an operation

  611       // is performed

  612

  613       public bool Tick()

  614       {

  615         if (++currentInc == updateIncrement)

  616         {

  617           pm.MeterProgress();

  618           currentInc = 0;

  619           System.Windows.Forms.Application.DoEvents();

  620         }

  621         // Check whether the filter has set the flag

  622         if (cancelled)

  623           pm.Stop();

  624

  625         return !cancelled;

  626       }

  627

  628       // The message filter callback

  629

  630       public bool PreFilterMessage(

  631         ref System.Windows.Forms.Message m

  632       )

  633       {

  634         if (m.Msg == WM_KEYDOWN)

  635         {

  636           // Check for the Escape keypress

  637           System.Windows.Forms.Keys kc =

  638             (System.Windows.Forms.Keys)(int)m.WParam &

  639             System.Windows.Forms.Keys.KeyCode;

  640

  641           if (m.Msg == WM_KEYDOWN &&

  642               kc == System.Windows.Forms.Keys.Escape)

  643           {

  644             cancelled = true;

  645           }

  646

  647           // Return true to filter all keypresses

  648           return true;

  649         }

  650         // Return false to let other messages through

  651         return false;

  652       }

  653     }

  654   }

  655 }

  656

Here's the source the source file for download.