Through the Interface

Turning AutoCAD into a Spirograph using F#

I’ve been toying for some time with the idea of writing some code to turn AutoCAD into a Spirograph, a device which I’m sure fascinated and inspired many of you as children (just as it did me). I chose to write the application in F# for a couple of reasons: this type of task is fundamentally mathematical in nature – so a functional programming language should be well-suited to the task – and I needed to dust off my F# skills in time for my F# class at AU. Searching the web I came across this helpful post providing some functional C# code to plot points along the path followed by a Spirograph (in this case for UI automation), which in turn referenced a post with the underlying mathematics stated relatively simply.

I won’t bother reproducing the relevant contents of these two posts: please visit them if you’re interested in the background to the code. The changes I’ve made have largely been around gathering the appropriate information needed to customize each path. The code creates a simple polyline with plain-old linear segments (we’ll use enough to easily approximate a curve, although choosing this “simple” approach means we need to create more segments than would otherwise been needed to show the path smoothly, which clearly means heavier objects).

Here’s some F# code to create Spirograph-style patterns in AutoCAD:

// Declare a specific namespace and module name

 

module Spirograph.Commands

 

// Import managed assemblies

 

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open System

 

// Return a sampling of points along a Spirograph's path

 

let pointsOnSpirograph cenX cenY inRad outRad a tStart tEnd =

  [|

    for i in tStart .. tEnd * 10 do

 

      let t = (float i) * 0.1

      let diff = inRad - outRad

      let ratio = inRad / outRad

      let x =

        diff * Math.Cos(ratio * t) +

          a * Math.Cos((1.0 - ratio) * t)

      let y =

        diff * Math.Sin(ratio * t) -

          a * Math.Sin((1.0 - ratio) * t)

 

      yield new Point2d(cenX + x, cenY + y)

  |]

 

// Our command

 

[<CommandMethod("spi")>]

let spirograph() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // Prompt the user for the center of the spirograph

 

  let cenRes = ed.GetPoint("\nSelect center point: ")

 

  if cenRes.Status = PromptStatus.OK then

 

    let cen = cenRes.Value

 

    // Now the radius of the outer circle

 

    let pdo =

      new PromptDistanceOptions

        ("\nEnter radius of outer circle: ")

    pdo.BasePoint <- cen

    pdo.UseBasePoint <- true

 

    let radRes = ed.GetDistance(pdo)

 

    if radRes.Status = PromptStatus.OK then

 

      let outerRad = radRes.Value

 

      // And the radius of the smaller circle

 

      pdo.Message <-

        "\nEnter radius of smaller circle: "

 

      let loopRes = ed.GetDistance(pdo)     

 

      if loopRes.Status = PromptStatus.OK then

 

        let innerRad = loopRes.Value

 

        // And finally the value of "a", the distance of the

        // "pen" from the center of the smaller circle

 

        pdo.Message <-

          "\nEnter pen distance from center of smaller circle: "

 

        let aRes = ed.GetDistance(pdo)

 

        if aRes.Status = PromptStatus.OK then

 

          let a = aRes.Value

 

          // Now we can get a sampling of points along our path

 

          let pts =

            pointsOnSpirograph

              cen.X cen.Y innerRad outerRad a 0 300

 

          // And we'll add a simple polyline with these points

 

          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

 

          let pl = new Polyline(pts.Length)

          pl.SetDatabaseDefaults()

 

          // Add the various vertices to the polyline

 

          for i in 0 .. pts.Length-1 do

            pl.AddVertexAt(i, pts.[i], 0.0, 0.0, 0.0)

 

          // Add our polyline to the modelspace

 

          let id = ms.AppendEntity(pl)

          tr.AddNewlyCreatedDBObject(pl, true)

 

          tr.Commit()

When we run our SPI command we get prompted for a number of parameters: the centre of the path, the radius of the outer circle, the radius of the smaller circle which will “roll” around the outer one, and finally the position of the pen relative to the centre of the smaller circle:

Command: SPI

Select center point:

Enter radius of outer circle:

Enter radius of smaller circle:

Enter pen distance from center of smaller circle:

Here’s a simple script you can execute to create a number of simple paths (by copy and pasting the contents into a text file, saving it with the .SCR extension, and running it inside AutoCAD via the SCRIPT command):

SPI 0,0,0 10 5 3

SPI 12,0,0 10 6 4

SPI 28,0,0 10 3 2

SPI 48,0,0 8 1 3

SPI 68,0,0 10 3 1

SPI 84,0,0 8 2 4

SPI 100,0,0 8 1 2

SPI 116,0,0 8 2 2

SPI 132,0,0 10 3 3

SPI 150,0,0 10 2 .3

SPI 168,0,0 10 3 .5

SPI 185,0,0 12 7 3

SPI 202,0,0 12 7 4

Which creates these fairly simple Spirograph paths:

By just playing around selecting values you can come up with much more complex shapes:

[A quick aside regarding the command’s user-input: the various distances are input relative to the centre of the Spirograph, which isn’t ideal. I would probably have preferred to select the last two items - the smaller circle radius and the pen distance – relative to the center of the smaller circle. But as we’re using GetDistance() to get the outer radius we’d have to choose an arbitrary location for this circle, which would actually have made the selection process more confusing. If we knew where the distance point was actually selected we could implement this easily, but using GetPoint() instead of GetDistance() (along with some simple vector arithmetic to calculate the underlying distance between the two circles’ centres) means the user couldn’t then enter a numerical value for the outer radius (which would make it all more confusing still). Implementing a jig to display temporary circles etc. as the locations get selected would probably be the way to go, should we want to turn this into a real application, but as it’s all really just a bit of fun I’m going to leave it at that. :-)]

AU 2009: Attend one of my sessions from the comfort of your armchair

Seeing Jeremy's post from Friday, I decided to give you a quick update of where I am with my own preparation for this year’s Autodesk University.

I’m delivering two sessions, this year:

• CP9214-1 AutoCAD® .NET – Developing for AutoCAD Using F#
• CP208-1 AutoCAD® .NET – Developing for AutoCAD Using IronPython and IronRuby

So yes, it seems as though I’m carving out a niche for myself as “the quirky languages guy”. :-)

The first one of these is actually a virtual session, and will be broadcast twice during the week of AU. It’s one I presented already, last year, and here you’ll find both parts of last year’s handouts, although as the F# language has evolved over the last year I’ve had to make some updates that I’ll post, in due course. The good news about it being a virtual session is that you don’t need to travel to Las Vegas to attend the session (I’ll be online from Las Vegas during both the broadcast slots to answer any questions that attendees might have).

The second session I’m presenting is a physical one (in that I’ll be in the same room as the attendees, the only exercise involved will be mental, I assure you :-) and is covering brand new content. During the session we’ll look at the benefits of dynamic programming languages and then focus on integrating IronPython and IronRuby with AutoCAD. We’ll work through a number of samples I’ve posted here, such as jigging solids and turning lines and circles into pipes using the Overrule API in AutoCAD 2010.

For anyone with an interest in broadening their horizons from a programming language perspective (something in which I’m personally a strong believer), I thoroughly recommend signing up for one or other of these classes.

Here is a little more information on AU Virtual:

• Event date: December 1-4, 2009
• 50+ Classes and Sessions streamed “live”
• A “Premium Pass” (full access) is only US$99
• All Subscription customers receive a free “Premier Pass”
• A “Free Pass” (limited access) is available to anyone
• How AU Virtual compares with AU “On-Site”

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):

Winner of the F# programming contest

Back at the beginning of the year I launched a programming contest for using F# with Autodesk products. A few months ago I introduced one of the winning entries showing how to use F# to implement Overrules in AutoCAD 2010. Now I’ve finally got around to unveiling the second winning entry.

And the winner is… drumroll…

Nada Amin, who entered her Master of Engineering project which uses F# with AutoCAD. Here is a description of the project from the MIT website:

Micado: an AutoCAD plug-in for programmable microfluidic chips

Programmable microfluidics, using multi-layer soft lithography, are lab-on-chip systems that can automate biological computations or experiments by integrating a diverse set of biological sensors and by manipulating fluids at the picoliter scale.

Micado is a Computer-Aided Design (CAD) tool for designing and controlling programmable microfluidics, featuring:

• standard and customizable design rules
• automatic routing between control valves and punches
• automatic generation of control instructions and GUI

The code is hosted here (under which you will find the majority of the code having been written in F#).

Nada is now based over in Zürich, so I hope someday to meet with her to discuss the project in person, but in the meantime I’ll be shipping across a copy of Expert F#.

Congratulations, Nada! :-)

Customizing the display of standard AutoCAD objects using F#

This post is one of the winning entries of the F# programming contest started at the beginning of the year. It was submitted by an old friend of mine, Qun Lu, who also happens to be a member of the AutoCAD engineering team, and makes use of a new API in AutoCAD 2010: the somewhat ominously-named Overrule API.

The Overrule API is really (and I mean really, really) cool. Yes, I know: another really cool API in AutoCAD 2010? Well, I’m honestly not one to hype things up, but I do have a tendency to get excited by technology that has incredibly interesting capabilities with a relatively low barrier of entry. And the Overrule API is one of those APIs. It’s the answer to the question posed in this previous post, which raises concerns about translating the power and complexity of custom objects to the world of .NET:

So what’s the right thing to do? Clearly we could just go ahead and expose the mechanism as it is today in ObjectARX. And yet here we are with a technology we know to be highly complex and difficult to implement, and an ideal opportunity to redesign it – enabling more people to harness it effectively at lower effort. The more favoured approach (at least from our perspective) would be to investigate further how better to meet developers’ needs for enabling custom graphics/behaviour (a.k.a. stylization) in AutoCAD – in a way that could be supported technically for many releases to come.

The Overrule API allows you to hook into the display and other aspects of the behaviour of entities inside AutoCAD. The below example is a great example: when enabled, the code overrules the display of lines and circles, to make them into coloured pipes. And all with very little code (which would also be true if the code were in C# or VB.NET).

Here’s the F# code:

#light

 

module DrawOverrule.Commands

 

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.Geometry

open Autodesk.AutoCAD.GraphicsInterface

open Autodesk.AutoCAD.Colors

 

type public DrawOverrule public () as this =

  inherit DrawableOverrule()

 

  static member public theOverrule =

    new DrawOverrule()

 

  static member private Radius = 0.5

 

  member private this.sweepOpts = new SweepOptions()

 

  override this.WorldDraw (d : Drawable, wd : WorldDraw) =

    match d with

      // Type-test and cast. If succeeds, cast to "line"

      | :? Line as line ->

        // Draw the line as is, with overruled attributes

        base.WorldDraw(line, wd) |> ignore

        if not line.Id.IsNull && line.Length > 0.0 then

          // Draw a pipe around the line

          let c = wd.SubEntityTraits.TrueColor

          wd.SubEntityTraits.TrueColor <-

            new EntityColor(0x00AfAfff)

          wd.SubEntityTraits.LineWeight <-

            LineWeight.LineWeight000

          let clr =

            new Circle

              (line.StartPoint, line.EndPoint-line.StartPoint,

              DrawOverrule.Radius)

          let pipe = new ExtrudedSurface()

          try

            pipe.CreateExtrudedSurface

              (clr, line.EndPoint-line.StartPoint, this.sweepOpts)

          with

            | e -> printfn("Failed with CreateExtrudedSurface")

          clr.Dispose()

          pipe.WorldDraw(wd) |> ignore

          pipe.Dispose()

          wd.SubEntityTraits.TrueColor <- c

        true

      | :? Circle as circle ->

        // Draw the circle as is, with overruled attributes

        base.WorldDraw(circle, wd) |> ignore

 

        // needed to avoid ill-formed swept surface

        if circle.Radius > DrawOverrule.Radius then

          // draw a pipe around the cirle

          let c = wd.SubEntityTraits.TrueColor

          wd.SubEntityTraits.TrueColor <-

            new EntityColor(0x3fffe0e0)

          wd.SubEntityTraits.LineWeight <-

            LineWeight.LineWeight000

          let normal =

            (circle.Center-circle.StartPoint).

              CrossProduct(circle.Normal)

          let clr =

            new Circle

              (circle.StartPoint, normal, DrawOverrule.Radius)

          let pipe = new SweptSurface()

          pipe.CreateSweptSurface(clr, circle, this.sweepOpts)

          clr.Dispose()

          pipe.WorldDraw(wd) |> ignore

          pipe.Dispose()

          wd.SubEntityTraits.TrueColor <- c

        true

      | _ ->

        base.WorldDraw(d, wd)

 

  override this.SetAttributes (d : Drawable, t : DrawableTraits) =

    let b = base.SetAttributes(d, t)

    match d with

      | :? Line ->

        // If d is LINE, set color to index 6

        t.Color <- 6s

        // and lineweight to .40 mm

        t.LineWeight <- LineWeight.LineWeight040

      | :? Circle ->   

        // If d is CIRCLE, set color to index 2

        t.Color <- 2s

        // and lineweight to .60 mm

        t.LineWeight <- LineWeight.LineWeight060

      | _ -> ()

    b

 

let Overrule enable =

  // Regen to see the effect

  // (turn on/off Overruling and LWDISPLAY)

  DrawableOverrule.Overruling <- enable

  match enable with

    | true -> Application.SetSystemVariable("LWDISPLAY", 1)

    | false -> Application.SetSystemVariable("LWDISPLAY", 0)

  let doc =

    Application.DocumentManager.MdiActiveDocument

  doc.SendStringToExecute("REGEN3\n", true, false, false)

  doc.Editor.Regen()

 

// Now we declare our commands

 

[<CommandMethod("overrule1")>]

let OverruleStart() =

  // Targeting all Drawables, but only affects Lines and Circles

  ObjectOverrule.AddOverrule

    (RXClass.GetClass(typeof<Drawable>),

    DrawOverrule.theOverrule, true)

  Overrule(true)

 

[<CommandMethod("overrule0")>]

let OverruleEnd() =

  Overrule(false)

Here’s what happens when we load the application, turn the overrule on using the OVERRULE1 command (OVERRULE0 is the command to turn the overrule off – it’s details like this that tell you Qun’s a real programmer… ;-) and draw some lines and circles:

Even in a 3D view – this time with the realistic visual style applied – you get the piping effect when you draw simple geometry:

To be clear: these are standard AutoCAD lines and circles. When you use the OVERRULE0 command to disable the overrule, they revert to their original form:

I expect to follow this post – in time – with various more harnessing the power of this very cool API. If you have questions or ideas about how it might be used, be sure to post a comment.

Thanks & congratulations, Qun! Your copy of “Expert F#” is on its way to you via inter-office mail. :-) More soon on the other winning entry…

Using IronPython with AutoCAD

I’ve been meaning to play around with the Python language for some time, now, and with the recent release of IronPython 2 it seems a good time to start.

Why Python? A number of people in my team – including Jeremy Tammik and the people within our Media  & Entertainment workgroup who support Python’s use with Maya and MotionBuilder – are fierce proponents of the language. I’m told that it’s an extremely easy, general-purpose, dynamic programming language. All of which sounds interesting, of course, although I have to admit I’m less convinced of the importance of the dynamic piece: I’ve found a lot of value in static typing over the years (even F# is statically typed, although many people – even some who work with it - don’t realise this… its type inference system allows you to code safely without specifying types all over the place).

Let’s take a quick step back and talk about what makes a language dynamic. The most common example of a dynamic language – one that I’m sure most of you will have touched at some point – is JavaScript. In JavaScript you declare everything as a var, assign it, call methods on it and hope that they work at runtime. I admit that I’ve always disliked developing in JavaScript because of the lack of decent tool support: I’m a big fan of Intellisense (based on an object’s design-time type) and want the compiler to tell me if I’m dealing with an object that doesn’t support a particular method. But perhaps that’s largely what I’ve become used to from modern development tools, and I’m trying to remain open to new things. Really, I am.

Another dynamic language with which I’ve had much more favourable (but still, at times, frustrating) experiences is LISP. But my relationship with LISP is different: like most early AutoCAD programmers I adopted it out of necessity – and at the time I started with it programming environments were, in any case, generally very basic - I then grew to love it and have since never forgotten it, even when more attractive/productive development environments came along. So I’m extremely loathe to paint it with the same brush as the one I’ve used for JavaScript.

Python is also of interest because of its cross-platform availability: it’s an open source language with its roots in the UNIX/Linux world, but is now gaining popularity across a variety of OS platforms (one of the reasons it’s the scripting language chosen for at least one of our cross-platform products, Autodesk Maya).

Microsoft is definitely now very open to the possibilities of dynamic languages: they’re making a significant investment in the Dynamic Language Runtime, to support languages such as IronPython and IronRuby, as well as adding more dynamic features with C# 4.0 (which is finally going to get something comparable to VB’s “late binding” capability).

So all in all, the world we live in seems to be becoming increasingly dynamic. :-)

Anyway – now on to getting IronPython working with AutoCAD. I had originally hoped to build a .NET assembly directly using IronPython – something that appears to have been enabled with the 2.0 release of IronPython - which could then be loaded into AutoCAD. Unfortunately this was an exercise in frustration: AutoCAD makes heavy use of custom attributes for identifying commands etc., but IronPython doesn’t currently support the use of attributes. It is possible to do some clever stuff by compiling attributed C# on-the-fly and deriving classes from it (information on this is available here), which will – in theory, at least – get you something in memory that’s attributed but, as AutoCAD scans the physical assembly for custom attributes before loading it, this didn’t help. I also spent a great deal of time just trying to derive a class from Autodesk.AutoCAD.Runtime.IExtensionApplication – to have the Initialize() function called automatically on load – but I just couldn’t get this to work, either.

Then, thankfully, Tim Riley came to the rescue: we’ve been in touch on and off over the years since he started the PyAcad.NET project to run IronPython code inside AutoCAD, and Tim was able to put together some working code which actually registered commands (after I’d pointed him at a function he could use from AutoCAD 2009’s acmgdinternal.dll – an unsupported assembly that exposes some otherwise quite helpful functions). He ended up choosing an implementation that had also been suggested to me by Albert Szilvasy: to implement a PYLOAD command using C# which allows selection and loading of a Python script (because Python is, ultimately, all about scripting rather than building static, compiled assemblies).

Before we get on to the C# module, I should point out that I installed IronPython 2.0.1 as well as IronPython Studio 1.0 for the Visual Studio 2008 integration. It turns out that as we’re relying on C# to manage the loading of Python – rather than compiling a .NET assembly – the main advantage of IronPython Studio is around the ability to work with Python source code inside Visual Studio.

To build the below C# code into a standard .NET Class Library assembly (a .DLL) you’ll need to add assembly references to IronPython.dll, IronPython.Modules.dll, Microsoft.Scripting.dll and Microsoft.Scripting.Core.dll – all of which can be found in the main IronPython install folder (on my system this is in “C:\Program Files\IronPython 2.0.1”). As well as the standard references to acmgd.dll and acdbmgd.dll, of course.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.EditorInput;

using IronPython.Hosting;

using Microsoft.Scripting.Hosting;

using System;

 

namespace PythonLoader

{

  public class CommandsAndFunctions

  {

    [CommandMethod("-PYLOAD")]

    public static void PythonLoadCmdLine()

    {

      PythonLoad(true);

    }

 

    [CommandMethod("PYLOAD")]

    public static void PythonLoadUI()

    {

      PythonLoad(false);

    }

 

    public static void PythonLoad(bool useCmdLine)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      short fd =

        (short)Application.GetSystemVariable("FILEDIA");

 

      // As the user to select a .py file

 

      PromptOpenFileOptions pfo =

          new PromptOpenFileOptions(

            "Select Python script to load"

          );

      pfo.Filter = "Python script (*.py)|*.py";

      pfo.PreferCommandLine =

        (useCmdLine || fd == 0);

      PromptFileNameResult pr =

        ed.GetFileNameForOpen(pfo);

 

      // And then try to load and execute it

 

      if (pr.Status == PromptStatus.OK)

        ExecutePythonScript(pr.StringResult);

    }

 

    [LispFunction("PYLOAD")]

    public ResultBuffer PythonLoadLISP(ResultBuffer rb)

    {

      const int RTSTR = 5005;

 

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      if (rb == null)

      {

        ed.WriteMessage("\nError: too few arguments\n");

      }

      else

      {

        // We're only really interested in the first argument

 

        Array args = rb.AsArray();

        TypedValue tv = (TypedValue)args.GetValue(0);

 

        // Which should be the filename of our script

 

        if (tv != null && tv.TypeCode == RTSTR)

        {

          // If we manage to execute it, let's return the

          // filename as the result of the function

          // (just as (arxload) does)

 

          bool success =

            ExecutePythonScript(Convert.ToString(tv.Value));

          return

            (success ?

              new ResultBuffer(

                new TypedValue(RTSTR, tv.Value)

              )

              : null);

        }

      }

      return null;

    }

 

    private static bool ExecutePythonScript(string file)

    {

      // If the file exists, let's load and execute it

      // (we could/should probably add some more robust

      // exception handling here)

 

      bool ret = System.IO.File.Exists(file);

      if (ret)

      {

        ScriptEngine engine = Python.CreateEngine();

        engine.ExecuteFile(file);

      }

      return ret;

    }

  }

}

The code behind the PYLOAD command is actually really simple. I could have kept it basic but decided it would be a good opportunity to show some best practices. So not only do we have the standard PYLOAD command, which respects the FILEDIA variable to decide whether to use dialogs or the command-line, we also have a command-line version –PYLOAD and a LISP function (pyload). All of which call into the same function to load a Python script.

OK, now let’s take a look at a simple IronPython script that calls into AutoCAD via its .NET API. Thanks again to Tim Riley for providing something that works. Even with Python being (apparently) so easy to learn, I’m such a neophyte that without his help I’d still be stumbling around in the dark.

import clr

path = 'C:\\Program Files\\Autodesk\\AutoCAD 2009\\'

clr.AddReferenceToFileAndPath(path + 'acdbmgd.dll')

clr.AddReferenceToFileAndPath(path + 'acmgd.dll')

clr.AddReferenceToFileAndPath(path + 'acmgdinternal.dll')

 

import Autodesk

import Autodesk.AutoCAD.Runtime as ar

import Autodesk.AutoCAD.ApplicationServices as aas

import Autodesk.AutoCAD.DatabaseServices as ads

import Autodesk.AutoCAD.Geometry as ag

import Autodesk.AutoCAD.Internal as ai

from Autodesk.AutoCAD.Internal import Utils

 

# Function to register AutoCAD commands

# To be used via a function decorator

 

def autocad_command(function):

 

    # First query the function name

    n = function.__name__

 

    # Create the callback and add the command

    cc = ai.CommandCallback(function)

    Utils.AddCommand('pycmds', n, n, ar.CommandFlags.Modal, cc)

 

    # Let's now write a message to the command-line

    doc = aas.Application.DocumentManager.MdiActiveDocument

    ed = doc.Editor

    ed.WriteMessage("\nRegistered Python command: {0}", n)

 

# A simple "Hello World!" command

 

@autocad_command

def msg():

    doc = aas.Application.DocumentManager.MdiActiveDocument

    ed = doc.Editor

    ed.WriteMessage("\nOur test command works!")

 

# And one to do something a little more complex...

# Adds a circle to the current space

 

@autocad_command

def mycir():

 

    doc = aas.Application.DocumentManager.MdiActiveDocument

    db = doc.Database

 

    tr = doc.TransactionManager.StartTransaction()

    bt = tr.GetObject(db.BlockTableId, ads.OpenMode.ForRead)

    btr = tr.GetObject(db.CurrentSpaceId, ads.OpenMode.ForWrite)

 

    cir = ads.Circle(ag.Point3d(10,10,0),ag.Vector3d.ZAxis, 2)

 

    btr.AppendEntity(cir)

    tr.AddNewlyCreatedDBObject(cir, True)

 

    tr.Commit()

    tr.Dispose()

As we’re stuck without the ability to use custom attributes in IronPython, we’re making use of the Autodesk.AutoCAD.Internal namespace to register commands at runtime. I don’t like doing this, but at the same time I was left with little choice, unless we choose to find another way to call into the code. Please be warned that anything contained in the Autodesk.AutoCAD.Internal namespace is unsupported functionality, and subject to change without warning.

Now that I have that off my chest, let’s comment a little further on the above code…

• Even without custom attributes, we have used a pretty cool Python language feature known as decorators (thanks *again* for the tip, Tim :-) which helps us to mark functions as commands. The autocad_command function is called for each decorated function, and this is where we register a command for the function based on the function’s name. Pretty cool.
• You’ll notice a distinct lack of types in the code (and yes, that still scares me). When I was previously trying to compile a DLL based on this code, I had a lot of trouble getting anything at all to fail at compile-time, but clearly a lot would fail at runtime (when I could actually get anything to execute :-S). I feel as though I still need to get my head around this trade-off: I can see the argument for simplicity/elegance/succinctness – and even the power it brings in some situations - but the Computer Scientist in me is screaming for safety/reliability/determinism/debuggability (if that’s even a word). Oh well. The main thing is that I’m starting the journey, at least: we’ll see if it ends up somewhere I like. :-)

When we build and NETLOAD our PythonLoader C# application and execute the PYLOAD command, we can select our Python script:

Command: PYLOAD

Once selected, the script gets loaded and should register a couple of commands:

Registered Python command: msg

Registered Python command: mycir

Running the MSG command will execute a simple “Hello World!”-like function, just printing a message to the command-line:

Command: MSG

Our test command works!

And running the MYCIR command should just add a simple circle to the current space in the active drawing.

Command: MYCIR

That’s it for my initial foray into the world of Python. I hope you’ve found this helpful and enjoy playing around with the Python programming language inside AutoCAD. Please do post a comment if you have experiences or anecdotes to share on this topic!

Reminder: F# programming contest deadline looming...

There are just a few days left before the February 28th deadline of the F# programming contest. Thanks to those of you who have already submitted entries!

At least one potential prize is still up for grabs - beyond those I've ear-marked for existing entrants - so if you're working on something and plan on submitting it in the next week or two (even if you won't be able to meet the original deadline for the actual submission), then please let me know by email. If you haven't notified me by Saturday that you have something in the works then I'm afraid there's a good chance you won't be in the running for a prize.

Parallelized pixelization inside AutoCAD using F#

As promised in the last post, we're now going to look at how to change the code to make the colour averaging routine work in parallel. The overall performance is marginally better on my dual-core machine, but I fully expect it to get quicker and quicker as the number of cores multiply.

To start with, though, here's the modified "synchronous" version of the code - as I went through making the code work in parallel, I noticed a bunch of general enhancements that were applicable to both versions. Here's the updated F# code:

// Use lightweight F# syntax

 

#light

 

// Declare a specific namespace and module name

 

module SyncPixelizer.Commands

 

// Import managed assemblies

 

#nowarn "9" // ... because we're using NativePtr

 

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open Autodesk.AutoCAD.Colors

open System.Drawing.Imaging

open Microsoft.FSharp.NativeInterop

 

// Add up the RGB values of a list of pixels

 

// We use a recursive function with an accumulator argument,

// (rt, gt, bt), to allow tail call optimization

 

let rec sumColors (pix : List<(byte*byte*byte)>) (rt,gt,bt) =

  match pix with

    | [] -> (rt, gt, bt)

    | (r, g, b) :: tl ->

        sumColors tl

          (rt + Byte.to_int r,

          gt + Byte.to_int g,

          bt + Byte.to_int b)

 

// Average out the RGB values of a list of pixels

 

let getAverageColour (pixels : List<(byte*byte*byte)>) =

  let (rsum, gsum, bsum) =

    sumColors pixels (0, 0, 0)

  let count = pixels.Length

  let ravg = Byte.of_int (rsum / count)

  let gavg = Byte.of_int (gsum / count)

  let bavg = Byte.of_int (bsum / count)

 

  // For some reason the pixel needs ro be reversed - probably

  // because of the bitmap format (needs investigation)

 

  Color.FromRgb(bavg, gavg, ravg)

 

// Function to get an index into our flat array

// from an x,y pair

 

let getIndexFromXY ysize x y =

  (x * ysize) + y

 

//  Get a chunk of pixels to average from one row

 

// We use a recursive function with an accumulator argument

// to allow tail call optimization

 

let rec getChunkRowPixels p xsamp acc =

  if xsamp = 0 then

    acc

  else

    let pix =

      [(NativePtr.get p 0,

        NativePtr.get p 1,

        NativePtr.get p 2)]

    let p = NativePtr.add p 3 // We do *not* mutate here

    getChunkRowPixels p (xsamp-1) (pix @ acc)

 

// Get a chunk of pixels to average from multiple rows

 

// We use a recursive function with an accumulator argument

// to allow tail call optimization

 

let rec getChunkPixels p stride xsamp ysamp acc =

  if ysamp = 0 then

    acc

  else

    let pix = getChunkRowPixels p xsamp []

    let p = NativePtr.add p stride  // We do *not* mutate here

    getChunkPixels p stride xsamp (ysamp-1) (pix @ acc)

 

// Get the various chunks of pixels to average across

// a complete bitmap image

 

let pixelizeBitmap (image:System.Drawing.Bitmap) xsize ysize =

 

  // Create a 1-dimensional array of pixel lists (one list,

  // which then needs averaging, per final pixel)

 

  let (arr : List<(byte*byte*byte)>[]) =

    Array.create (xsize * ysize) []

 

  // Lock the entire memory block related to our image

 

  let bd =

    image.LockBits

      (System.Drawing.Rectangle

        (0, 0, image.Width ,image.Height),

      ImageLockMode.ReadOnly, image.PixelFormat)

 

  // Establish the number of pixels to sample per chunk

  // in each of the x and y directions

 

  let xsamp = image.Width / xsize

  let ysamp = image.Height / ysize

 

  // We have a mutable pointer to step through the image

 

  let mutable (p:nativeptr<byte>) =

    NativePtr.of_nativeint (bd.Scan0)

 

  // Loop through the various chunks

 

  for i = 0 to ysize - 1 do

 

    // We take a copy of the current value of p, as we

    // don't want to mutate p while extracting the pixels

    // within a row

 

    let mutable xp = p

    for j = 0 to xsize - 1 do

 

      // Get the square chunk of pixels starting at

      // this x,y position

 

      let chk =

        getChunkPixels xp bd.Stride xsamp ysamp []

 

      // Add it into our array

 

      let idx = getIndexFromXY ysize j (ysize-1-i)

      arr.[idx] <- chk

 

      // Mutate the pointer to move along to the right

      // by a value of 3 (our RGB value) times the

      // number of pixels we're sampling in x

 

      xp <- NativePtr.add xp (xsamp * 3)

    done

 

    // Mutate the original p pointer to move on one row

 

    p <- NativePtr.add p (bd.Stride * ysamp)

  done

 

  // Finally unlock the bitmap data and return the array

 

  image.UnlockBits(bd)

  arr

 

// Create an array of ObjectIds from a collection

 

let getIdArray (ids : ObjectIdCollection) =

  [| for i in [0..ids.Count-1] -> ids.[i] |]

 

// Declare our command

 

[<CommandMethod("pix")>]

let pixelize() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // Prompt the user for the file and the width of the image

 

  let pofo =

    new PromptOpenFileOptions

      ("Select an image to import and pixelize")

  pofo.Filter <-

    "Jpeg Image (*.jpg)|*.jpg|All files (*.*)|*.*"

  let pfnr = ed.GetFileNameForOpen(pofo)

 

  let file =

    match pfnr.Status with

    | PromptStatus.OK ->

        pfnr.StringResult

    | _ ->

        ""

 

  if System.IO.File.Exists(file) then

 

    let img = System.Drawing.Image.FromFile(file)

 

    let pio =

      new PromptIntegerOptions

        ("\nEnter number of horizontal pixels: ")

    pio.AllowNone <- true

    pio.UseDefaultValue <- true

    pio.LowerLimit <- 1

    pio.UpperLimit <- img.Width

    pio.DefaultValue <- 100

 

    let pir = ed.GetInteger(pio)

    let xsize =

      match pir.Status with

        | PromptStatus.None ->

            img.Width

        | PromptStatus.OK ->

            pir.Value

        | _ -> -1

 

    if xsize > 0 then

 

      // Calculate the vertical size from the horizontal

 

      let ysize = img.Height * xsize / img.Width

 

      if ysize > 0 then

 

        // We'll time the command, so we can check the

        // sync vs. async efficiency

 

        let starttime = System.DateTime.Now

 

        // "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

 

        // Function to create a filled circle (hatch) at a

        // specific location

 

        // Note the valid use of tr and ms, as they are in scope

 

        let createCircle pt rad =

          let hat = new Hatch()

          hat.SetDatabaseDefaults()

          hat.SetHatchPattern

            (HatchPatternType.PreDefined,

            "SOLID")

 

          let id = ms.AppendEntity(hat)

          tr.AddNewlyCreatedDBObject(hat, true)

 

          // Now we create the loop, which we make db-resident

          // (appending a transient loop caused problems, so

          // we're going to use the circle and then erase it)

 

          let cir = new Circle()

          cir.Radius <- rad

          cir.Center <- pt

 

          let lid = ms.AppendEntity(cir)

          tr.AddNewlyCreatedDBObject(cir, true)

 

          // Have the hatch use the loop we created

 

          let loops = new ObjectIdCollection()

          loops.Add(lid) |> ignore

          hat.AppendLoop(HatchLoopTypes.Default, loops)

          hat.EvaluateHatch(true)

 

          // Now we erase the loop

 

          cir.Erase()

          id

 

        // Function to create our grid of circles

 

        let createGrid xsize ysize rad offset =

          let ids = new ObjectIdCollection()

          for i = 0 to xsize - 1 do

            for j = 0 to ysize - 1 do

              let pt =

                new Point3d

                  (offset * (Int32.to_float i),

                   offset * (Int32.to_float j),

                   0.0)

              let id = createCircle pt rad

              ids.Add(id) |> ignore

          ids

 

        // Function to change the colour of an entity

 

        let changeColour (id : ObjectId) (col : Color) =

          if id.IsValid then

            let ent =

              tr.GetObject(id, OpenMode.ForWrite) :?> Entity

            ent.Color <- col

 

        // Create our basic grid

 

        let ids = createGrid xsize ysize 0.5 1.2

 

        // Cast our image to a bitmap and then

        // get the chunked pixels

 

        let bmp = img :?> System.Drawing.Bitmap

        let arr = pixelizeBitmap bmp xsize ysize

 

        // Loop through the pixel list and average them out

        // (which could be parallelized), using the results

        // to change the colour of the circles in our grid

 

        Array.map getAverageColour arr |>

          Array.iter2 changeColour (getIdArray ids)

 

        // Commit the transaction

 

        tr.Commit()

 

        // Check how long it took

 

        let elapsed =

          System.DateTime.op_Subtraction

            (System.DateTime.Now, starttime)

 

        ed.WriteMessage

          ("\nElapsed time: " + elapsed.ToString())

To change this to run the colour averaging asynchronously (in parallel, if you have the cores) is really simple. We replace one line of code "Array.map getAverageColour arr" with the following:

Async.Run

  (Async.Parallel

    [ for a in arr ->

        async { return getAverageColour a }])

This essentially performs a parallel array map (albeit a somewhat naive one), returning basically the same results as the previous line - just hopefully a little more quickly. In case you want to build the two files into one project to test them side-by-side, here they are, the synchronous and asynchronous versions, with the changes needed to allow them to live in and execute from the same assembly.

Here's one more image that's been processed by the PIX command:

In case you're interested, the original image can be found here.

Importing and pixelizing images inside AutoCAD using F#

A friend and esteemed colleague asked - very validly - why I decided to use circles on a grid to display the results of a mathematical function in this last post, rather than using a linear object of some kind. Well I did, in fact, have a plan in mind... :-)

This post extends the concept, introduced in that post, of displaying data in a grid of solid-hatched circles. This post focuses on importing a bitmap image from a file, pixelizing the contents and using the "averaged" pixel colours to modify our grid. The idea actually came to me during an R.E.M. concert I attended at Paléo, a Swiss music festival, last summer. The real-time manipulation performed on the live video feed of the band - and especially of Michael Stipe, the lead singer - which was then projected onto screens adjacent to the stage was really, really cool. They managed to pixelize and manipulate the colours in a way that I found incredible - it was like seeing real-time graphic design at work. I understand that much of the work is done in advance, but even so I found it very impressive. Some of you regular concert-goers may find what I've just described to be pretty run-of-the-mill, but I fully admit that these days - what with one thing and another - I don't get out much. :-)

The pixelization approach I decided to take was to read in square chunks of the bitmap image and then average out the RGB values for all the pixels in each square. These average values are then used to colour the circles representing the "pixels" for their respective squares. You'll notice some inadvertent cropping of the imported image, which happens because we ask for the width in terms of our circular pixels and then sample the bitmap in chunks that have a whole number of pixels on each side: if the picture's width is not exactly divisible by the width entered there will be a little cropping.

Why did I choose F# for this rather than C#? The image processing domain in general is a strong fit for functional programming techniques. And while I haven't yet taken the step in this post, certain parts of the below code are inherently parallelizable, especially the operations related to averaging of pixel colours. The reading of the bitmap itself might prove more difficult, as it uses "unsafe" direct memory access (via the NativePtr class), but it's by no means impossible to parallelize, at least in theory.

Anyway, here's the F# code I put together:

// Use lightweight F# syntax

#light

// Declare a specific namespace and module name

module Pixelizor.Commands

// Import managed assemblies

#nowarn "9" // ... because we're using NativePtr

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open Autodesk.AutoCAD.Colors

open System.Drawing.Imaging

open Microsoft.FSharp.NativeInterop

// Declare our command

[<CommandMethod("pix")>]

let pixelate() =

  // Let's get the usual helpful AutoCAD objects

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

  // "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

  // Function to create a filled circle (hatch) at a

  // specific location

  // Note the valid use of tr and ms, as they are in scope

  let createCircle pt rad =

    let hat = new Hatch()

    hat.SetDatabaseDefaults()

    hat.SetHatchPattern

      (HatchPatternType.PreDefined,

      "SOLID")

    let id = ms.AppendEntity(hat)

    tr.AddNewlyCreatedDBObject(hat, true)

    // Now we create the loop, which we make db-resident

    // (appending a transient loop caused problems, so

    // we're going to use the circle and then erase it)

    let cir = new Circle()

    cir.Radius <- rad

    cir.Center <- pt

    let lid = ms.AppendEntity(cir)

    tr.AddNewlyCreatedDBObject(cir, true)

    // Have the hatch use the loop we created

    let loops = new ObjectIdCollection()

    loops.Add(lid) |> ignore

    hat.AppendLoop(HatchLoopTypes.Default, loops)

    hat.EvaluateHatch(true)

    // Now we erase the loop

    cir.Erase()

    id

  // Function to create our grid of circles

  let createGrid xsize ysize rad offset =

    let ids = new ObjectIdCollection()

    for i = 0 to xsize - 1 do

      for j = 0 to ysize - 1 do

        let pt =

          new Point3d

            (offset * (Int32.to_float i),

            offset * (Int32.to_float j),

            0.0)

        let id = createCircle pt rad

        ids.Add(id) |> ignore

    ids

  // Function to change the colour of an entity

  let changeColour (col : Color) (id : ObjectId) =

    if id.IsValid then

      let ent =

        tr.GetObject(id, OpenMode.ForWrite) :?> Entity

      ent.Color <- col

  // Add up the RGB values of a list of pixels

  // We use a recursive function with an accumulator argument,

  // (rt, gt, bt), to allow tail call optimization

  let rec sumColors (pix : List<(byte*byte*byte)>) (rt,gt,bt) =

    match pix with

      | [] -> (rt, gt, bt)

      | (r, g, b) :: tl ->

          sumColors tl

            (rt + Byte.to_int r,

            gt + Byte.to_int g,

            bt + Byte.to_int b)

  // Average out the RGB values of a list of pixels

  let getAverageColour (pixels : List<(byte*byte*byte)>) =

    let (rsum, gsum, bsum) =

      sumColors pixels (0, 0, 0)

    let count = pixels.Length

    let ravg = Byte.of_int (rsum / count)

    let gavg = Byte.of_int (gsum / count)

    let bavg = Byte.of_int (bsum / count)

    // For some reason the pixel needs ro be reversed - probably

    // because of the bitmap format (needs investigation)

    Color.FromRgb(bavg, gavg, ravg)

  //  Get a chunk of pixels to average from one row

  // We use a recursive function with an accumulator argument

  // to allow tail call optimization

  let rec getChunkRowPixels p xsamp acc =

    if xsamp = 0 then

      acc

    else

      let pix =

        [(NativePtr.get p 0,

          NativePtr.get p 1,

          NativePtr.get p 2)]

      let p = NativePtr.add p 3

      getChunkRowPixels p (xsamp-1) (pix @ acc)

  // Get a chunk of pixels to average from multiple rows

  // We use a recursive function with an accumulator argument

  // to allow tail call optimization

  let rec getChunkPixels p stride xsamp ysamp acc =

    if ysamp = 0 then

      acc

    else

      let pix = getChunkRowPixels p xsamp []

      let p = NativePtr.add p stride

      getChunkPixels p stride xsamp (ysamp-1) (pix @ acc)

  // Get the various chunks of pixels to average across

  // a complete bitmap image

  let pixelateBitmap (image:System.Drawing.Bitmap) xsize ysize =

    // Create a 2-dimensional array of pixel lists (one list,

    // which then needs averaging, per final pixel)

    let (arr2 : List<(byte*byte*byte)>[,]) =

      Array2.create xsize ysize []

    // Lock the entire memory block related to our image

    let bd =

      image.LockBits

        (System.Drawing.Rectangle

          (0, 0, image.Width ,image.Height),

        ImageLockMode.ReadOnly, image.PixelFormat)

    // Establish the number of pixels to sample per chunk

    // in each of the x and y directions

    let xsamp = image.Width / xsize

    let ysamp = image.Height / ysize

    // We have a mutable pointer to step through the image

    let mutable (p:nativeptr<byte>) =

      NativePtr.of_nativeint (bd.Scan0)

    // Loop through the various chunks

    for i = 0 to ysize - 1 do

      // We take a copy of the current value of p, as we

      // don't want to mutate p while extracting the pixels

      // within a row

      let mutable xp = p

      for j = 0 to xsize - 1 do

        // Get the square chunk of pixels starting at

        // this x,y position

        let chk =

          getChunkPixels xp bd.Stride xsamp ysamp []

        // Add it into our array

        arr2.[j,ysize-1-i] <- chk

        // Mutate the pointer to move along to the right

        // by a value of 3 (our RGB value) times the

        // number of pixels we're sampling in x

        xp <- NativePtr.add xp (xsamp * 3)

      done

      // Mutate the original p pointer to move on one row

      p <- NativePtr.add p (bd.Stride * ysamp)

    done

    // Finally unlock the bitmap data and return the array

    image.UnlockBits(bd)

    arr2

  // Prompt the user for the file and the width of the image

  let pofo =

    new PromptOpenFileOptions

      ("Select an image to import and pixelate")

  pofo.Filter <-

    "Jpeg Image (*.jpg)|*.jpg|All files (*.*)|*.*"

  let pfnr = ed.GetFileNameForOpen(pofo)

  let file =

    match pfnr.Status with

    | PromptStatus.OK ->

        pfnr.StringResult

    | _ ->

        ""

  if System.IO.File.Exists(file) then

    let img = System.Drawing.Image.FromFile(file)

    let pio =

      new PromptIntegerOptions

        ("\nEnter number of horizontal pixels: " )

    pio.AllowNone <- true

    pio.UseDefaultValue <- true

    pio.LowerLimit <- 1

    pio.UpperLimit <- img.Width

    pio.DefaultValue <- 100

    let pir = ed.GetInteger(pio)

    let xsize =

      match pir.Status with

        | PromptStatus.None ->

            img.Width

        | PromptStatus.OK ->

            pir.Value

        | _ -> -1

    if xsize > 0 then

      // Calculate the vertical size from the horizontal

      let ysize = img.Height * xsize / img.Width

      if ysize > 0 then

        // Create our basic grid

        let ids = createGrid xsize ysize 0.5 1.2

        // Some helper functions using values we've just set...

        // From a certain index in the list, get an object ID

        let getId i =

          if i >= 0 then

            ids.[i]

          else

            ObjectId.Null

        // From a certain x and y in the grid, get an object ID

        let getId x y =

          getId ((x * ysize) + y)

        // Cast our image to a bitmap and then

        // get the chunked pixels

        let bmp = img :?> System.Drawing.Bitmap

        let arr = pixelateBitmap bmp xsize ysize

        // Loop through the pixel list and average them out

        // (which could be parallelized), using the results

        // to change the colour of the circles in our grid

        for x = 0 to xsize - 1 do

          for y = 0 to ysize - 1 do

            let lst = arr.[x,y]

            let col = getAverageColour lst

            let id = getId x y

            changeColour col id

          done

        done

  // Commit the transaction

  tr.Commit()

Here are the results of running it and choosing a photo I took yesterday during my visit to Kodaikanal in Tamil Nadu (India's most southern state).

First the original image:

Here's what happens when we run the PIX command, selecting the above image and choosing 20 pixels in width:

 

Now with a width of 50...

And finally with a width of 100...

 

Give it a try yourself, pixelizing different images at different resolutions - you can get some very cool results.

This one is too fun to just let rest... I'm going to see if I get some time this week to work on the parallelization of the colour averaging operation, to see if that improves performance (even if it doesn't today, it will do eventually when I either get a 64-core machine or move some of the code to be hosted in the cloud... :-)

Implementing a simple graphing tool inside AutoCAD using F#

Well, I couldn't resist... as I mentioned in the last post - where we looked at creating a simple graph inside AutoCAD as an example of modifying objects inside nested transactions - the idea of graphing inside AutoCAD is a good fit for F#. This is for a number of reasons: F# is very mathematical in nature and excels at processing lists of data. I also spiced it up a bit by adding some code to parallelise some of the mathematical operations, but that didn't turn out to be especially compelling with my dual-core laptop. More on that later.

Here's the F# code:

// Use lightweight F# syntax

#light

// Declare a specific namespace and module name

module Grapher.Commands

// Import managed assemblies

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.Geometry

// Define a common normalization function which makes sure

// our graph gets mapped to our grid

let normalize fn normFn x minInp maxInp maxOut =

  let res =

    fn ((maxInp - minInp) * x / maxOut)

  let normRes = normFn res

  if normRes >= 0.0 && normRes <= 1.0 then

    normRes * (maxOut - 1.0)

  else

    -1.0

// Define some shortcuts to the .NET Math library

// trigonometry functions

let sin x = System.Math.Sin x

let cos x = System.Math.Cos x       

let tan x = System.Math.Tan x       

// Implement our own normalized trig functions

// which each map to the size of the grid passed in

let normSin max x =

  let nf a = (a + 1.0) / 2.0 // Normalise to 0-1

  let res =

    normalize

      sin nf (Int32.to_float x)

      0.0 (2.0 * System.Math.PI) (Int32.to_float max)

  Int32.of_float res

let normCos max x =

  let nf a = (a + 1.0) / 2.0 // Normalise to 0-1

  let res =

    normalize

      cos nf (Int32.to_float x)

      0.0 (2.0 * System.Math.PI) (Int32.to_float max)

  Int32.of_float res

let normTan max x =

  let nf a = (a + 3.0) / 6.0 // Normalise differently for tan

  let res =

    normalize

      tan nf (Int32.to_float x)

      0.0 (2.0 * System.Math.PI) (Int32.to_float max)

  Int32.of_float res

// Now we declare our command

[<CommandMethod("graph")>]

let gridCommand() =

  // We'll time the command, so we can check the

  // sync vs. async efficiency

  let starttime = System.DateTime.Now

  // Let's get the usual helpful AutoCAD objects

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

  // "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

  // Function to create a filled circle (hatch) at a

  // specific location

  // Note the valid use of tr and ms, as they are in scope

  let createCircle pt rad =

    let hat = new Hatch()

    hat.SetDatabaseDefaults();

    hat.SetHatchPattern

      (HatchPatternType.PreDefined,

       "SOLID")

    let id = ms.AppendEntity(hat)

    tr.AddNewlyCreatedDBObject(hat, true)

    // Now we create the loop, which we make db-resident

    // (appending a transient loop caused problems, so

    // we're going to use the circle and then erase it)

    let cir = new Circle()

    cir.Radius <- rad

    cir.Center <- pt

    let lid = ms.AppendEntity(cir)

    tr.AddNewlyCreatedDBObject(cir, true)

    // Have the hatch use the loop we created

    let loops = new ObjectIdCollection()

    loops.Add(lid) |> ignore

    hat.AppendLoop(HatchLoopTypes.Default, loops)

    hat.EvaluateHatch(true)

    // Now we erase the loop

    cir.Erase()

    id

  // Function to create our grid of circles

  let createGrid size rad offset =

    let ids = new ObjectIdCollection()

    for i = 0 to size - 1 do

      for j = 0 to size - 1 do

        let pt =

          new Point3d

            (offset * (Int32.to_float i),

            offset * (Int32.to_float j),

            0.0)

        let id = createCircle pt rad

        ids.Add(id) |> ignore

    ids

  // Function to change the colour of an entity

  let changeColour col (id : ObjectId) =

    if id.IsValid then

      let ent =

        tr.GetObject(id, OpenMode.ForWrite) :?> Entity

      ent.ColorIndex <- col

  // Shortcuts to make objects red and yellow

  let makeRed = changeColour 1

  let makeYellow = changeColour 2

  // Function to retrieve the contents of our

  // array of object IDs - this just calculates

  // the index based on the x & y values

  let getIndex fn size i =

    let res = fn size i

    if res >= 0 then

        (i * size) + res

    else

        -1

  // Apply our function synchronously for each value of x

  let applySyncBelowMax size fn =

    [| for i in [0..size-1] ->

       getIndex fn size i |]

  // Apply our function asynchronously for each value of x

  let applyAsyncBelowMax size fn =

    Async.Run

      (Async.Parallel

        [ for i in [0..size-1] ->

          async { return getIndex fn size i } ])

  // Hardcode the size of the grid and create it

  let size = 50

  let ids = createGrid size 0.5 1.2

  // Make the circles all red to start with

  Seq.iter makeRed (Seq.cast ids)

  // From a certain index in the list, get an object ID

  let getId i =

    if i >= 0 then

      ids.[i]

    else

      ObjectId.Null

  // Apply one of our trig functions, synchronously or

  // otherwise, to our grid

  applySyncBelowMax size normSin |>

    Array.map getId |>

      Array.iter makeYellow

  // Commit the transaction

  tr.Commit()

  // Check how long it took

  let elapsed =

      System.DateTime.op_Subtraction

        (System.DateTime.Now, starttime)

  ed.WriteMessage

    ("\nElapsed time: " +

    elapsed.ToString())

 

Here's what you see on AutoCAD's drawing canvas when you run the GRAPH command as it stands:

If you want to play around with other functions, you can edit the call to applySyncBelowMax to pass normCos or normTan instead of normSin.

 

As I mentioned earlier, if you swap the call to be applyAsyncBelowMax instead of applySyncBelowMax you will actually run the mathematics piece as asynchronous tasks. These are CPU-bound operations - they don't call across the network or write to a hard-drive, which might have increased the benefit of calling them asynchronously - so right now the async version actually runs more slowly than the sync version. If I were to have more processing cores available to me, it might also give us more benefit, but right now with my dual-core machine there's more effort spent coordinating the tasks than you gain from the parallelism. But I'll let you play around with that yourselves... you may get better results. One other note on that piece of the code: at some point I'd like to make use of the Parallel Extensions for .NET (in particular the Task Parallel Library (TPL)), but for now I've continued with what I know, the asynchronous worklows capability which is now standard in F#.

I'm travelling in India this week (and working from our Bangalore office next week), so this is likely to be my last post of the week.