Through the Interface

Overruling AutoCAD 2010’s entity display and explode using IronPython

To continue my investigations into IronPython and the fun I’m having with overrules, I decided to to port my most recent C# overrule implementation across to IronPython. I’ve also been trying to do the same for IronRuby, but – so far – without luck.

Please refer back to one of the previous IronPython posts for the PYLOAD command implementation needed to load our Python script into AutoCAD.

Here are the contents of our .py file:

import clr

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

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

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

 

import Autodesk

import Autodesk.AutoCAD.Runtime as ar

import Autodesk.AutoCAD.ApplicationServices as aas

import Autodesk.AutoCAD.DatabaseServices as ads

import Autodesk.AutoCAD.EditorInput as aei

import Autodesk.AutoCAD.GraphicsInterface as agi

import Autodesk.AutoCAD.Geometry as ag

import Autodesk.AutoCAD.Colors as ac

import Autodesk.AutoCAD.Internal as ai

from Autodesk.AutoCAD.Internal import Utils

 

def autocad_command(function):

  """

  Function to register AutoCAD commands

  To be used via a function decorator

  """

 

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

 

appName = "TTIF_PIPE"

appCode = 1001

radCode = 1040

 

def PipeRadiusForObject(obj):

 

  """

  Get the XData for a particular object

  and return the "pipe radius" if it exists

  """

 

  res = 0.0

 

  try:

    rb = obj.XData

    if rb is None:

      return res

 

    foundStart = False

 

    for tv in rb:

      if tv.TypeCode == appCode and tv.Value == appName:

        foundStart = True

      else:

        if foundStart:

          if tv.TypeCode == radCode:

            res = tv.Value

            break

 

    rb.Dispose()

  except:

    return 0.0

  return res

 

def SetPipeRadiusOnObject(tr, obj, radius):

 

  """

  Set the pipe radius as XData on a particular object

  """

 

  db = obj.Database

 

  # Make sure the application is registered

  # (we could separate this out to be called

  # only once for a set of operations)

 

  rat = tr.GetObject(db.RegAppTableId, ads.OpenMode.ForRead)

 

  if not rat.Has(appName):

    rat.UpgradeOpen()

    ratr = ads.RegAppTableRecord()

    ratr.Name = appName

    rat.Add(ratr)

    tr.AddNewlyCreatedDBObject(ratr, True)

 

  # Create the XData and set it on the object

 

  rb = ads.ResultBuffer(

      ads.TypedValue(appCode, appName),

      ads.TypedValue(radCode, radius)

    )

  obj.XData = rb

  rb.Dispose()

 

class PipeDrawOverrule(agi.DrawableOverrule):

 

  """

  The base class for our draw overrules specifying the

  registered application name for the XData upon which

  to filter

  """

 

  def __init__(self):

 

    # Tell AutoCAD to filter on our application name

    # (this means our overrule will only be called

    # on objects possessing XData with this name)

 

    self.SetXDataFilter(appName) 

 

class LinePipeDrawOverrule(PipeDrawOverrule):

 

  """

  An overrule to make a pipe out of a line

  """

 

  def __init__(self):

    self._sweepOpts = ads.SweepOptions()

 

  def WorldDraw(self, d, wd):

 

    radius = PipeRadiusForObject(d)

 

    if radius > 0.0:

      # Draw the line as is, with overruled attributes

 

      PipeDrawOverrule.WorldDraw(self, d, wd)

      if not d.Id.IsNull and d.Length > 0.0:

        # Draw a pipe around the line

 

        c = wd.SubEntityTraits.TrueColor

        wd.SubEntityTraits.TrueColor = ac.EntityColor(0x00AFAFFF)

        wd.SubEntityTraits.LineWeight = ads.LineWeight.LineWeight000

        start = d.StartPoint

        end = d.EndPoint

        norm = ag.Vector3d(

          end.X - start.X,

          end.Y - start.Y,

          end.Z - start.Z

        )

        clr = ads.Circle(start, norm, radius)

        pipe = ads.ExtrudedSurface()

        try:

          pipe.CreateExtrudedSurface(clr, norm, self._sweepOpts)

        except:

          doc = aas.Application.DocumentManager.MdiActiveDocument

          doc.Editor.WriteMessage(

            "\nFailed with CreateExtrudedSurface."

          )

        clr.Dispose()

        pipe.WorldDraw(wd)

        pipe.Dispose()

        wd.SubEntityTraits.TrueColor = c

      return True

    return PipeDrawOverrule.WorldDraw(self, d, wd)

 

  def SetAttributes(self, d, t):

 

    b = PipeDrawOverrule.SetAttributes(self, d, t)

 

    radius = PipeRadiusForObject(d)

 

    if radius > 0.0:

      # Set color to magenta

      t.Color = 6

      # and lineweight to .40 mm

      t.LineWeight = ads.LineWeight.LineWeight040

 

    return b

 

class CirclePipeDrawOverrule(PipeDrawOverrule):

 

  """

  An overrule to make a pipe out of a circle

  """

 

  def __init__(self):

    self._sweepOpts = ads.SweepOptions()

 

  def WorldDraw(self, d, wd):

 

    radius = PipeRadiusForObject(d)

 

    if radius > 0.0:

      # Draw the circle as is, with overruled attributes

 

      PipeDrawOverrule.WorldDraw(self, d, wd)

 

      # Needed to avoid ill-formed swept surface

 

      if d.Radius > radius:

        # Draw a pipe around the circle

 

        c = wd.SubEntityTraits.TrueColor

        wd.SubEntityTraits.TrueColor = ac.EntityColor(0x3FFFE0E0)

        wd.SubEntityTraits.LineWeight = ads.LineWeight.LineWeight000

        start = d.StartPoint

        cen = d.Center

        norm = ag.Vector3d(

          cen.X - start.X,

          cen.Y - start.Y,

          cen.Z - start.Z

        )

        clr = ads.Circle(start, norm.CrossProduct(d.Normal), radius)

        pipe = ads.SweptSurface()

        pipe.CreateSweptSurface(clr, d, self._sweepOpts)

        clr.Dispose()

        pipe.WorldDraw(wd)

        pipe.Dispose()

        wd.SubEntityTraits.TrueColor = c

      return True

    return PipeDrawOverrule.WorldDraw(self, d, wd)

 

  def SetAttributes(self, d, t):

 

    b = PipeDrawOverrule.SetAttributes(self, d, t)

 

    radius = PipeRadiusForObject(d)

 

    if radius > 0.0:

      # Set color to yellow

      t.Color = 2

      # and lineweight to .60 mm

      t.LineWeight = ads.LineWeight.LineWeight060

 

    return b

 

class LinePipeTransformOverrule(ads.TransformOverrule):

 

  """

  An overrule to explode a linear pipe into Solid3d objects

  """

 

  def __init__(self):

    self._sweepOpts = ads.SweepOptions()

 

  def Explode(self, e, objs):

    radius = PipeRadiusForObject(e)

 

    if radius > 0.0:

      if not e.Id.IsNull and e.Length > 0.0:

        # Draw a pipe around the line

 

        start = e.StartPoint

        end = e.EndPoint

        norm = ag.Vector3d(

          end.X - start.X,

          end.Y - start.Y,

          end.Z - start.Z

        )

        clr = ads.Circle(start, norm, radius)

        pipe = ads.ExtrudedSurface()

        try:

          pipe.CreateExtrudedSurface(clr, norm, self._sweepOpts)

        except:

          doc = aas.Application.DocumentManager.MdiActiveDocument

          doc.Editor.WriteMessage(

            "\nFailed with CreateExtrudedSurface."

          )

        clr.Dispose()

        objs.Add(pipe)

      return

    PipeDrawOverrule.Explode(self, e, objs)

 

class CirclePipeTransformOverrule(ads.TransformOverrule):

 

  """

  An overrule to explode a circular pipe into Solid3d objects

  """

 

  def __init__(self):

    self._sweepOpts = ads.SweepOptions()

 

  def Explode(self, e, objs):

    radius = PipeRadiusForObject(e)

 

    if radius > 0.0:

      if e.Radius > radius:

 

        start = e.StartPoint

        cen = e.Center

        norm = ag.Vector3d(

          cen.X - start.X,

          cen.Y - start.Y,

          cen.Z - start.Z

        )

        clr = ads.Circle(start, norm.CrossProduct(e.Normal), radius)

        pipe = ads.SweptSurface()

        pipe.CreateSweptSurface(clr, e, self._sweepOpts)

        clr.Dispose()

        objs.Add(pipe)

      return

    PipeDrawOverrule.Explode(self, e, objs)

 

def Overrule(enable):

 

  # Regen to see the effect

  # (turn on/off Overruling and LWDISPLAY)

 

  ar.Overrule.Overruling = enable

  if enable:

    aas.Application.SetSystemVariable("LWDISPLAY", 1)

  else:

    aas.Application.SetSystemVariable("LWDISPLAY", 0)

 

  doc = aas.Application.DocumentManager.MdiActiveDocument

  doc.SendStringToExecute("REGEN3\n", True, False, False)

  doc.Editor.Regen()

 

# Set some global variables

 

radius = 0.0

overruling = False

lpdo = LinePipeDrawOverrule()

cpdo = CirclePipeDrawOverrule()

lpto = LinePipeTransformOverrule()

cpto = CirclePipeTransformOverrule()

 

class Commands:

 

  @autocad_command

  def Overrule1():

 

    # Only add the overrule if not currently attached

 

    global overruling

    if not overruling:

 

      # Create a temporary line to get its class

      # (this may not be the best way)

 

      ln = ads.Line()

      ads.ObjectOverrule.AddOverrule(

        ar.RXClass.GetClass(ln.GetType()),

        lpdo,

        True

      )

      ads.ObjectOverrule.AddOverrule(

        ar.RXClass.GetClass(ln.GetType()),

        lpto,

        True

      )

      ln.Dispose()

 

      # Create a temporary circle to get its class

      # (this may not be the best way)

 

      c = ads.Circle()

      ads.ObjectOverrule.AddOverrule(

        ar.RXClass.GetClass(c.GetType()),

        cpdo,

        True

      )

      ads.ObjectOverrule.AddOverrule(

        ar.RXClass.GetClass(c.GetType()),

        cpto,

        True

      )

      c.Dispose()

 

      overruling = True

      Overrule(True)

 

  @autocad_command

  def Overrule0():

 

    # Only remove the overrule if previously added

 

    global overruling

    if overruling:

 

      # Create a temporary line to get its class

      # (this may not be the best way)

 

      ln = ads.Line()

      ads.ObjectOverrule.RemoveOverrule(

        ar.RXClass.GetClass(ln.GetType()),

        lpdo

      )

      ads.ObjectOverrule.RemoveOverrule(

        ar.RXClass.GetClass(ln.GetType()),

        lpto

      )

      ln.Dispose()

 

      # Create a temporary circle to get its class

      # (this may not be the best way)

 

      c = ads.Circle()

      ads.ObjectOverrule.RemoveOverrule(

        ar.RXClass.GetClass(c.GetType()),

        cpdo

      )

      ads.ObjectOverrule.RemoveOverrule(

        ar.RXClass.GetClass(c.GetType()),

        cpto

      )

      c.Dispose()

 

      overruling = False

      Overrule(False)

 

  @autocad_command

  def MakePipe():

 

    doc = aas.Application.DocumentManager.MdiActiveDocument

    db = doc.Database

    ed = doc.Editor

 

    # Pick up the radius from the global scope

 

    global radius

 

    # Ask the user to select the entities to make into pipes

 

    pso = aei.PromptSelectionOptions()

    pso.AllowDuplicates = False

    pso.MessageForAdding = "\nSelect objects to turn into pipes: "

 

    selRes = ed.GetSelection(pso)

 

    # If the user didn't make valid selection, we return

 

    if selRes.Status <> aei.PromptStatus.OK:

      return

 

    ss = selRes.Value

 

    # Ask the user for the pipe radius to set

 

    pdo = aei.PromptDoubleOptions("\nSpecify pipe radius:")

 

    # Use the previous value, if if already called

 

    if radius > 0.0:

      pdo.DefaultValue = radius

      pdo.UseDefaultValue = True

 

    pdo.AllowNegative = False

    pdo.AllowZero = False

 

    pdr = ed.GetDouble(pdo)

 

    # Return if something went wrong

 

    if pdr.Status <> aei.PromptStatus.OK:

      return

 

    # Set the "last radius" value for when

    # the command is called next

 

    radius = pdr.Value

 

    # Use a transaction to edit our various objects

 

    tr = db.TransactionManager.StartTransaction()

 

    # Loop through the selected objects

 

    for o in ss:

 

      # We could choose only to add XData to the objects

      # we know will use it (Lines and Circles, for now)

 

      obj = tr.GetObject(o.ObjectId, ads.OpenMode.ForWrite)

 

      SetPipeRadiusOnObject(tr, obj, radius)

 

    tr.Commit()

    tr.Dispose()

Once you have built your loader application and used PYLOAD to load your .py script, you should be able to use MAKEPIPE and OVERRULE1 to create pipes:

And EXPLODE to reduce them to Solid3d objects:

The logic in the code is basically same as that used in C#, although I have added some checks to make sure nothing bad happens if you call OVERRULE1 or OVERRULE0 repeatedly (previously I did not check for this, which could lead to an exception).

Jigging an AutoCAD solid using IronPython and .NET

After getting my feet wet in the last post with my first IronPython application running inside AutoCAD, I decided it was time to attack a slightly more challenging problem: jigging a database-resident Solid3d object. The idea had come after I’d received a question by email from David Wolfe, who wanted to have a fully rendered 3D view of a cylinder he was jigging.

I’d done something similar for a prototype application I worked on late last year (which was demoed at AU). The jig itself only collected the selection data I needed – the display of the Solid3d objects was handled either via the Transient Graphics subsystem or by modifying database-resident Solid3d objects (which were interconnected by a separate system of relationships and constraints). But anyway, the point is that only when the Solid3d objects were database-resident could I get rendered graphics to be generated for them via either the conceptual or realistic visual styles.

Which is why it occurred to me that the technique shown in this recent post for jigging db-resident blocks with attributes might also apply here, too.

And, just for fun, why not do the whole thing in Python? (Actually, which hindsight I can now think of a lot of reasons… :-)

Part of my rationale behind attempting this was that we were going to have to derive our jig class from EntityJig and make sure the appropriate methods were overridden for AutoCAD to then call our jig at the right moments. This is something I had doubts about being able to do, given my previous experience. IronPython is surprisingly good at allowing these methods to be implemented and called dynamically – something that I expect will grow on me – but the downside was that with the PYLOAD integration we used in the last post it is very hard to tell why things aren’t working. It took me a number of hours to work out that an __init__ function was needed – one which took an Entity and passed it to the constructor of the base class, EntityJig – and that without it the application would simply crash. A tighter integration of Python inside AutoCAD - and, I expect, overall better tooling for IronPython when working with .NET classes - would probably help avoid this kind of thrashing, but with what we have today it was pretty painful.

Before we look at the Python code, here’s an update version of the C# PythonLoader functionality: the only real difference being the try-catch block around the code which hosts our IronPython scripting engine and calls ExecuteFile():

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)

      {

        try

        {

          ScriptEngine engine = Python.CreateEngine();

          engine.ExecuteFile(file);

        }

        catch (System.Exception ex)

        {

          Document doc =

            Application.DocumentManager.MdiActiveDocument;

          Editor ed = doc.Editor;

 

          ed.WriteMessage(

            "\nProblem executing script: {0}", ex.Message

          );

        }

      }

      return ret;

    }

  }

}

And here’s the IronPython code for jigging a box inside AutoCAD:

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.EditorInput as aei

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 jig to create a Solid3d - in this case a box

 

class SolidJig(aei.EntityJig):

 

  # Initialization function

 

  def __init__(self, ent):

 

    # Store the object and call the base class

 

    self._sol = ent

    aei.EntityJig.__init__(self, ent)

 

  # The function called to run the jig

 

  def StartJig(self, ed, pt):

 

    # The start point is specific outside the jig

 

    self._start = pt

    self._end = pt

    return ed.Drag(self)

 

  # The sampler function

 

  def Sampler(self, prompts):

 

    # Set up our selection options

 

    jo = aei.JigPromptPointOptions()

    jo.UserInputControls = (

      aei.UserInputControls.Accept3dCoordinates |

      aei.UserInputControls.NoZeroResponseAccepted |

      aei.UserInputControls.NoNegativeResponseAccepted)

    jo.Message = "\nSelect end point: "     

 

    # Get the end point of our box

 

    res = prompts.AcquirePoint(jo)

    if self._end == res.Value:

      return aei.SamplerStatus.NoChange

    else:

      self._end = res.Value

    return aei.SamplerStatus.OK

 

  # The update function

 

  def Update(self):

 

    # Recreate our Solid3d box

 

    try:

      # Get the width (x) and depth (y)

 

      x = self._end.X - self._start.X

      y = self._end.Y - self._start.Y

 

      # We need a non-zero Z value, so we copy Y

 

      z = y

 

      # Create our box and move it to the right place

 

      self._sol.CreateBox(x,y,z)

      self._sol.TransformBy(

        ag.Matrix3d.Displacement(

          ag.Vector3d(

            self._start.X + x/2,

            self._start.Y + y/2,

            self._start.Z + z/2)))

    except:

      return False

    return True

 

# Create a box using a jig

 

@autocad_command

def boxjig():

 

  doc = aas.Application.DocumentManager.MdiActiveDocument

  db = doc.Database

  ed = doc.Editor

 

  # Select the start point before entering the jig

 

  ppr = ed.GetPoint("\nSelect start point: ")

 

  if ppr.Status == aei.PromptStatus.OK:

 

    # We'll add our solid to the modelspace

 

    tr = doc.TransactionManager.StartTransaction()

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

    btr = tr.GetObject(

      bt[ads.BlockTableRecord.ModelSpace], ads.OpenMode.ForWrite)

 

    # Make sure we're recording history to allow grip editing

 

    sol = ads.Solid3d()

    sol.RecordHistory = True

 

    # Now we add our solid

 

    btr.AppendEntity(sol)

    tr.AddNewlyCreatedDBObject(sol, True)

 

    # And call the jig before finishing

 

    sj = SolidJig(sol) 

    ppr2 = sj.StartJig(ed, ppr.Value)

 

    # Only commit if all completed well

 

    if ppr2.Status == aei.PromptStatus.OK:

      tr.Commit()

 

    tr.Dispose()

When we execute the PYLOAD command, load our .py file and execute the BOXJIG command, we’ll be able to jig a Solid3d in a non-wireframe 3D view:

 

Something to note: I haven’t spent time optimizing this code, so there’s a good chance it’s sub-optimal (and may well leak memory). The point was not to demonstrate a definitive approach to solving this particular problem but rather to see whether it was possible to attack a problem of non-trivial complexity with the current toolset and my general lack of knowledge of the Python language.

Well, it’s obviously possible – as I somehow managed to do it – but, to come clean, I did cheat somewhat: I had a C# project open at the same time which I regularly referred to for IntelliSense look-ups. I didn’t do my full development in C# and then convert it to Python, though, so I see this more as a stop-gap to help address some of the current limitations in the tools. That’s the story I’m going with, anyway. :-)

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!