« February 2009 | Main | April 2009 »
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…
A big thanks to Stephen Preston, who manages DevTech Americas and coordinates our worldwide AutoCAD workgroup as well as spending time working with the AutoCAD Engineering team (phew!), for providing this sample. Stephen originally put it together for our annual Developer Days tour late last year: I took the original sample, converted it from VB.NET to C# and made some minor changes to the code. The VB.NET version is available from the ADN website, in case.
The Free-Form Design feature in AutoCAD 2010 is one of the coolest enhancements to the product (I really like the Parametric Drawing feature, too, although as the API for that is currently C++-only it’s unfortunately going to get a little less air-time on this blog). This post looks at how to automate free-form design operations: starting with a traditional Solid3d object, converting it to a sub-division mesh (SubDMesh) which we then manipulate in a number of interesting ways before converting back to a Solid3d.
Here’s the C# code:
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.Colors;
using System.Collections.Generic;
using System;
namespace FreeformModeling
{
public class Commands
{
// Add a new mesh to the current space,
// setting it to a sphere primitive -
// no smoothing.
[CommandMethod("SPHM")]
public void SphericalMesh()
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Transaction tr =
doc.TransactionManager.StartTransaction();
using (tr)
{
BlockTableRecord btr =
(BlockTableRecord)tr.GetObject(
db.CurrentSpaceId,
OpenMode.ForWrite
);
SubDMesh mySubD = new SubDMesh();
mySubD.SetSphere(20, 8, 8, 0);
mySubD.SetDatabaseDefaults();
btr.AppendEntity(mySubD);
tr.AddNewlyCreatedDBObject(mySubD, true);
tr.Commit();
}
}
// Make clone of solid, inflate it by a fraction of its
// extents, create a mesh from the clone, erase the clone.
private ObjectId cloneAndInflateSolid(
Transaction tr, ObjectId solidId
)
{
// Now copy the solid
Document doc =
Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
ObjectId newId;
// Inflate solid by user specified fraction
// (0.05 works well with sample drawing)
PromptDoubleOptions pdo =
new PromptDoubleOptions(
"\nSpecify inflation as fraction of bounds:"
);
PromptDoubleResult pdr =
ed.GetDouble(pdo);
// Return if something went wrong.
if (pdr.Status != PromptStatus.OK)
return ObjectId.Null;
double frac = pdr.Value;
ObjectIdCollection ids = new ObjectIdCollection();
ids.Add(solidId);
IdMapping im = new IdMapping();
db.DeepCloneObjects(ids, db.CurrentSpaceId, im, false);
newId = im.Lookup(solidId).Value;
// We now have the ObjectID of the newly cloned
// solid in newId
// Inflate by length of diagonal vector across bounds
// multiplied by inflation fraction
Solid3d sol =
(Solid3d)tr.GetObject(newId, OpenMode.ForWrite);
Extents3d ext = (Extents3d)sol.Bounds;
Vector3d vec = ext.MaxPoint - ext.MinPoint;
sol.OffsetBody(vec.Length * frac);
// Define params governing mesh generation algorithm
// (See ObjectARX helpfiles for explanation of params)
MeshFaceterData fd =
new MeshFaceterData(
0.01 * vec.Length,
40 * Math.PI / 180,
2, 2, 15, 5, 5, 0
);
// Get the mesh data from the solid
// (with smoothing level 1).
MeshDataCollection mdc =
SubDMesh.GetObjectMesh(sol, fd);
// Create the mesh defined by this data.
SubDMesh sd = new SubDMesh();
sd.SetDatabaseDefaults();
sd.SetSubDMesh(mdc.VertexArray, mdc.FaceArray, 1);
// Add the mesh to database.
BlockTableRecord btr =
(BlockTableRecord)tr.GetObject(
db.CurrentSpaceId,
OpenMode.ForWrite
);
newId = btr.AppendEntity(sd);
tr.AddNewlyCreatedDBObject(sd, true);
// Erase the cloned solid
sol.Erase();
return newId;
}
// Add creases to user selected faces
// Returns true if successful
private bool addCreases(
Transaction tr, ObjectId meshId
)
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
PromptSelectionOptions pso =
new PromptSelectionOptions();
pso.ForceSubSelections = true;
pso.AllowDuplicates = false;
pso.MessageForAdding = "\nSelect edges to crease: ";
PromptSelectionResult selRes =
doc.Editor.GetSelection(pso);
// If the user didn't make valid selection, we return
if (selRes.Status != PromptStatus.OK)
return false;
SelectionSet ss = selRes.Value;
// They may have picked more than one object - we need
// the subobjects of the object with the right ObjectId
SelectedObject so = null;
foreach (SelectedObject o in ss)
{
if (o.ObjectId == meshId)
so = o;
}
// If they picked on the wrong object, then just don't
// add any extrusions
if (so == null)
return false;
// We got to here so selection was valid
// This will store selected edges
List<FullSubentityPath> creasePaths =
new List<FullSubentityPath>();
DBObject obj =
tr.GetObject(so.ObjectId, OpenMode.ForRead);
SubDMesh sd = obj as SubDMesh;
if (sd != null)
{
sd.UpgradeOpen();
// Add all selected subentities to the collection
SelectedSubObject[] subEnts =
so.GetSubentities();
foreach (SelectedSubObject subEnt in subEnts)
{
if (subEnt.FullSubentityPath.SubentId.Type
== SubentityType.Edge)
creasePaths.Add(subEnt.FullSubentityPath);
}
// Add infinite creases to all those edges
// -1 means 'always' crease
sd.SetCrease(creasePaths.ToArray(), -1);
return true;
}
return false;
}
// Extrude each mesh face by a random amount, up to a
// user specified maximum. Returns true if successful.
private bool extrudeFaces(
Transaction tr, ObjectId meshId
)
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
// Now we want to stretch a few faces to add a bit of
// randomness. Better just stretch outwards.
// Prompt for max random bump (0.02 works well for
// sample drawing).
PromptDoubleOptions pdo =
new PromptDoubleOptions(
"\nSpecify bump size as fraction of bounds: "
);
PromptDoubleResult pdr =
doc.Editor.GetDouble(pdo);
// If user cancels value entry, then we return.
if (pdr.Status != PromptStatus.OK)
return false;
double extrudelen = pdr.Value;
PromptSelectionOptions pso =
new PromptSelectionOptions();
pso.ForceSubSelections = true;
pso.MessageForAdding = "\nSelect faces to bump: ";
PromptSelectionResult psr =
doc.Editor.GetSelection(pso);
// If user cancels selection, then we assume they want
// to continue, but that they don't want to extrude any
// surfaces
if (psr.Status != PromptStatus.OK)
return false;
SelectionSet ss = psr.Value;
// They may have picked more than one object - we need
// the subobjects of the object with the right ObjectId
SelectedObject so = null;
foreach (SelectedObject o in ss)
{
if (o.ObjectId == meshId)
so = o;
}
if (so == null)
return false;
// If they picked on the wrong object, then just don't
// add any extrusions
// We got to here so selection was valid
// Stores faces we selected for random extrusion
List<FullSubentityPath> bumpPaths =
new List<FullSubentityPath>();
DBObject obj =
tr.GetObject(so.ObjectId, OpenMode.ForRead);
SubDMesh sd = obj as SubDMesh;
if (sd != null)
{
sd.UpgradeOpen();
SelectedSubObject[] subEnts =
so.GetSubentities();
// We'll be extruding faces by a random amount, so
// instantiate random number generator here ready
// to use inside loop
Random rnd = new Random();
// Process each selected face in turn
foreach (SelectedSubObject subEnt in subEnts)
{
// Is it a face?
if (subEnt.FullSubentityPath.SubentId.Type
== SubentityType.Face)
{
FullSubentityPath[] faces =
new FullSubentityPath[1];
faces[0] = subEnt.FullSubentityPath;
// Find normal for this face
Plane fPlane =
sd.GetFacePlane(faces[0].SubentId);
Vector3d norm = fPlane.Normal;
// Get length of diagonal across bounds to use
// in calculating bump scale
Extents3d ext = (Extents3d)sd.Bounds;
Vector3d vec = ext.MaxPoint - ext.MinPoint;
Matrix3d mat =
Matrix3d.Displacement(
norm * 0.5 * extrudelen *
rnd.NextDouble() * vec.Length
);
sd.TransformSubentityPathsBy(faces, mat);
}
}
return true;
}
return false;
}
// Set random color for each mesh face.
private void colorFaces(
Transaction tr, ObjectId meshId
)
{
Random rnd = new Random();
DBObject obj =
tr.GetObject(meshId, OpenMode.ForRead);
SubDMesh sd = obj as SubDMesh;
if (sd != null)
{
sd.UpgradeOpen();
// Iterate all faces and set to a random color
for (int i = 0; i <= sd.NumberOfFaces - 1; i++)
{
SubentityId sId =
new SubentityId(SubentityType.Face, i);
byte[] rgb = new byte[3];
rnd.NextBytes(rgb);
Color col =
Color.FromRgb(rgb[0], rgb[1], rgb[2]);
sd.SetSubentColor(sId, col);
}
}
}
private ObjectId convertToSolid(
Transaction tr, ObjectId meshId
)
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
ObjectId newId = ObjectId.Null;
DBObject obj =
tr.GetObject(meshId, OpenMode.ForRead);
SubDMesh sd = obj as SubDMesh;
if (sd != null)
{
sd.UpgradeOpen();
// ConvertToSolid will throw an exception if
// it can't create a solid from the mesh.
Solid3d sol = null;
try
{
sol = sd.ConvertToSolid(true, true);
}
catch
{
ed.WriteMessage(
"\nMesh was too complex to turn into a solid."
);
}
BlockTableRecord btr =
(BlockTableRecord)tr.GetObject(
db.CurrentSpaceId,
OpenMode.ForWrite
);
newId = btr.AppendEntity(sol);
tr.AddNewlyCreatedDBObject(sol, true);
}
return newId;
}
// Translates entity along x-axis by factor multiplied by
// the entity's extent along the x-axis.
private void translateEntity(
Transaction tr, ObjectId objId, double factor
)
{
Entity ent =
(Entity)tr.GetObject(
objId,
OpenMode.ForWrite
);
Extents3d ext = (Extents3d)ent.Bounds;
Point3d pt1 =
new Point3d(ext.MaxPoint.X, ext.MinPoint.Y, ext.MinPoint.Z);
Vector3d transVec =
factor * (pt1 - ext.MinPoint);
Matrix3d mat = Matrix3d.Displacement(transVec);
ent.TransformBy(mat);
}
// Creates a SubDMesh based on an 'inflated' clone of the
// selected solid. The user then gets to add creases and
// select which faces will be given a random extrusion.
// It colors each face of the mesh and then converts it to
// a smooth solid.
[CommandMethod("CC")]
public void CreateCasing()
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
Editor ed = doc.Editor;
ObjectId meshId;
// First select the solid (just one)
PromptEntityOptions peo =
new PromptEntityOptions("\nSelect a solid: ");
peo.SetRejectMessage("\nObject must be a 3D solid.");
peo.AddAllowedClass(typeof(Solid3d), false);
PromptEntityResult per = ed.GetEntity(peo);
if (per.Status != PromptStatus.OK)
return;
Transaction tr =
doc.TransactionManager.StartTransaction();
using (tr)
{
meshId =
cloneAndInflateSolid(tr, per.ObjectId);
// If the above call returned a null ObjectId,
// then something went wrong - we need to stop now
if (meshId == ObjectId.Null)
return;
// Now we have our original solid and the mesh
// created from the cloned solid
// Add creases
if (!addCreases(tr, meshId))
return;
// Randomly extrude faces
if (!extrudeFaces(tr, meshId))
return;
// Give faces random colors
colorFaces(tr, meshId);
// Convert the mesh to a solid.
ObjectId solId =
convertToSolid(tr, meshId);
// Move the entities so they don't sit on
// top of one other
translateEntity(tr, meshId, 1.5);
translateEntity(tr, solId, 3);
doc.TransactionManager.QueueForGraphicsFlush();
tr.Commit();
}
}
}
}
Here’s a sample 3D model – consisting of a single, composite 3D solid:
Here’s what happens when we run the CC command, selecting this solid and applying the recommended values (0.2 – i.e. 20% – for the inflation percentage and 0.05 – i.e. 5% – for the maximum random bump). I selected a number of edges and faces at random after which the code assigned random colours to all the faces, so please don’t get frustrated trying to reproduce these exact results. :-)
The objects are (going from right to left):
The best way to understand the overall functionality of the application is to scan the CC command – defined by the CreateCasing function found at the bottom of the listing – and then looking into individual functions it uses. The application also defines another command – SPHM – which shows how to create a simple, spherical sub-division mesh.
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. :-)
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…
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!
In the last post we looked at the code behind an ObjectARX module exposing AutoCAD's Properties Palette for use from managed .NET languages. Thanks again to Cyrille Fauvel for providing this implementation. In this post we're going to move right onto using this implementation from C#.
First things first: if you didn't understand much of what was said in the previous post in this series, Don't Panic! (Yes, that's a quick reference to The Hitchhiker's Guide to the Galaxy.) The actual implementation details aren't particularly important - you only really need to understand them if you want to expose additional interfaces to .NET in the same way (such as IFilterableProperty, the interface discussed in this previous post and something I expect to extend the application to handle, at some point).
Here is the project that contains both the ObjectARX module implementing exposing these interfaces and the sample we're showing today. You simply have to make sure the .NET module can find our asdkOPMNetExt.dll module (ideally both this and your .NET module should be located under AutoCAD's program folder).
Then you can simply implement code, as in the below sample, which loads and makes use of interfaces exposed by this assembly.
Here’s the C# code:
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Windows.OPM;
using System;
using System.Reflection;
using System.Runtime.InteropServices;
namespace OPMNetSample
{
#region Our Custom Property
[
Guid("F60AE3DA-0373-4d24-82D2-B2646517ABCB"),
ProgId("OPMNetSample.CustomProperty.1"),
// No class interface is generated for this class and
// no interface is marked as the default.
// Users are expected to expose functionality through
// interfaces that will be explicitly exposed by the object
// This means the object can only expose interfaces we define
ClassInterface(ClassInterfaceType.None),
// Set the default COM interface that will be used for
// Automation. Languages like: C#, C++ and VB allow to
//query for interface's we're interested in but Automation
// only aware languages like javascript do not allow to
// query interface(s) and create only the default one
ComDefaultInterface(typeof(IDynamicProperty2)),
ComVisible(true)
]
public class CustomProp : IDynamicProperty2
{
private IDynamicPropertyNotify2 m_pSink = null;
// Unique property ID
public void GetGUID(out Guid propGUID)
{
propGUID =
new Guid("F60AE3DA-0373-4d24-82D2-B2646517ABCB");
}
// Property display name
public void GetDisplayName(out string szName)
{
szName = "My integer property";
}
// Show/Hide property in the OPM, for this object instance
public void IsPropertyEnabled(object pUnk, out int bEnabled)
{
bEnabled = 1;
}
// Is property showing but disabled
public void IsPropertyReadOnly(out int bReadonly)
{
bReadonly = 0;
}
// Get the property description string
public void GetDescription(out string szName)
{
szName =
"This property is an integer";
}
// OPM will typically display these in an edit field
// optional: meta data representing property type name,
// ex. ACAD_ANGLE
public void GetCurrentValueName(out string szName)
{
throw new System.NotImplementedException();
}
// What is the property type, ex. VT_R8
public void GetCurrentValueType(out ushort varType)
{
// The Property Inspector supports the following data
// types for dynamic properties:
// VT_I2, VT_I4, VT_R4, VT_R8,VT_BSTR, VT_BOOL
// and VT_USERDEFINED.
varType = 3; // VT_I4
}
// Get the property value, passes the specific object
// we need the property value for.
public void GetCurrentValueData(object pUnk, ref object pVarData)
{
// TODO: Get the value and return it to AutoCAD
// Because we said the value type was a 32b int (VT_I4)
pVarData = (int)4;
}
// Set the property value, passes the specific object we
// want to set the property value for
public void SetCurrentValueData(object pUnk, object varData)
{
// TODO: Save the value returned to you
// Because we said the value type was a 32b int (VT_I4)
int myVal = (int)varData;
}
// OPM passes its implementation of IDynamicPropertyNotify, you
// cache it and call it to inform OPM your property has changed
public void Connect(object pSink)
{
m_pSink = (IDynamicPropertyNotify2)pSink;
}
public void Disconnect() {
m_pSink = null;
}
}
#endregion
#region Application Entry Point
public class MyEntryPoint : IExtensionApplication
{
protected internal CustomProp custProp = null;
public void Initialize()
{
Assembly.LoadFrom("asdkOPMNetExt.dll");
// Add the Dynamic Property
Dictionary classDict = SystemObjects.ClassDictionary;
RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
IPropertyManager2 pPropMan =
(IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
custProp = new CustomProp();
pPropMan.AddProperty((object)custProp);
}
public void Terminate()
{
// Remove the Dynamic Property
Dictionary classDict = SystemObjects.ClassDictionary;
RXClass lineDesc = (RXClass)classDict.At("AcDbLine");
IPropertyManager2 pPropMan =
(IPropertyManager2)xOPM.xGET_OPMPROPERTY_MANAGER(lineDesc);
pPropMan.RemoveProperty((object)custProp);
custProp = null;
}
}
#endregion
}
A few comments on what this code does…
It defines a class for our custom dynamic property (CustomProp), for which we need a unique GUID (and yes, by definition GUIDs are unique, but if you use the same one twice it ceases to be :-), and implement various callbacks to indicate the name, type, description and writeability of the property, as well as methods to get and set the property value. For this example our property is called “My integer property”, and – guess what? – it’s an integer, and has been hardcoded to have the value 4. We’re not actually storing the data being exposed via this property, but in a real-world application you would probably store it either as XData attached to the object, inside an XRecord in the object’s extension dictionary or in an external database of some kind.
In the rest of the code we’re defining functions that are called when the module is loaded and when AutoCAD terminates (see this previous post for more information on this mechanism). We use the Initialize() callback to load our mixed-mode module for which we presented the code in the last post (asdkOPMNetExt.dll) and then go ahead and instantiate our property and attach it to line objects.
When we build and load the sample, making sure the Properties Palette is visible (using the PROPS command or by double-clicking on the line) and selecting a line we’ve just drawn, we should see our dynamic property appear, as shown in this image.
If you don’t see the property appear, the application is probably having trouble loading asdkOPMNetExt.dll: as mentioned earlier I have placed both this and the sample application in the root folder of my AutoCAD installation. If you’re not sure whether the module is loaded properly, you can step through the Initialize() function in the debugger or add a simple command to your code which will obviously only work if your application has been loaded (the Assembly.LoadFrom() call will throw an exception if it doesn’t find the module, and if an exception is thrown from Initialize() the application will not be loaded, as described in this previous post).
For the sake of simplicity I’m going to leave this basic sample as having just one, hardwired property: hopefully it’s obvious how the application could be extended to handle more properties and to store these properties with their objects (if not, let me know by posting a comment and I’ll put together a more extensive example when I get the chance).
Subscribe via RSS