Through the Interface

Returning data from .NET to JavaScript inside AutoCAD

Here’s something else that may be of interest to people. As I was working towards the solution shown in the last post – before Albert told me about the ucsToWorld() function (thanks, Albert :-) – I ended up extending the .NET code we saw in the previous post to include a TransformToWcs() method (marshaled by a transToWcs() function on the JavaScript side of things). What’s interesting about this function – and has caused me to show it here, despite its existence being rendered redundant by ucsToWorld() – is that it returns a value to the caller by serializing point data into JSON (once again using Json.NET to save some effort).

Here’s the C# code:

[JavaScriptCallback("NetTransformToUcs")]

public string TransformToUcs(string jsonArgs)

{

  // Get the matrix of the current UCS

 

  var ed =

    Application.DocumentManager.MdiActiveDocument.Editor;

  var ucs = ed.CurrentUserCoordinateSystem;

 

  // Unpack our JSON-encoded parameters using Json.NET

 

  var o = JObject.Parse(jsonArgs);

  var x = (double)o["functionParams"]["point"]["x"];

  var y = (double)o["functionParams"]["point"]["y"];

  var z = (double)o["functionParams"]["point"]["z"];

 

  // Get and return our transformed point

 

  var point = new Point3d(x, y, z).TransformBy(ucs);

  return

    "{\"retCode\":0, \"result\":\"OK\", \"point\":" +

    JsonConvert.SerializeObject(point) + "}";

}

And here’s the JavaScript shaping code:

function transToWcs(pt) {

  var jsonResponse = exec(

    JSON.stringify({

      functionName: 'NetTransformToUcs',

      invokeAsCommand: false,

      functionParams: {

        point: pt

      }

    })

  );

  var jsonObj = JSON.parse(jsonResponse);

  if (jsonObj.retCode !== Acad.ErrorStatus.eJsOk) {

    throw Error(jsonObj.retErrorString);

  }

  var ret =

    new Acad.Point3d(

      parseFloat(jsonObj.point.X),

      parseFloat(jsonObj.point.Y),

      parseFloat(jsonObj.point.Z)

    );

  return ret;

}

That’s it for today: I just wanted to publish a quick one, as it’s a holiday for Autodesk here in Neuchatel (a bridging day after Ascension). Tomorrow I’ll be flying out to Singapore, but I’ll do my best to find the time to publish a few posts, next week.

Jigging AutoCAD geometry in an arbitrary UCS using JavaScript

I’ve learned a few things since the last post, where we complemented AutoCAD’s new JavaScript API with some additional .NET functionality to work around an issue that existed in the code we’d developed in the previous two posts.

Firstly, I found out there’s a better way for your jig to display transient graphics than via “manual” calls to addTransient(), updateTransient() and eraseTransient(). Acad.Jig exposes an update() function you can call, passing in the xml fragment representing your geometry. The jig will manage the display of the transient and clear it at the end. (Thanks to Sherry Tan for pointing me in this direction.) To make this work, you’ll need to assign your jig to a variable that’s in scope during its execution.

The problem is that this mechanism still exhibits the issue we had to work around last time: when you click on the circumference of a transient circle, the click doesn’t make it through. So I’ve modified the comments in today’s code to reflect the ideal implementation, but it doesn’t change our need to work around the current problematic behaviour.

The other two things I learned are that the jig – as we implemented it last time – doesn’t work well with a non-standard (i.e. non-world) UCS and that it causes very bad things to happen when you try to run it in two separate drawing windows at the same time. The first of these is a problem we’ll address in today’s post, the second is something I need to check in with some colleagues on: it may simply be a limitation of the current implementation that it doesn’t work well in an MDI context. We’ll see.

So, how do we get the jig working properly in an arbitrary UCS? There’s a handy method available that allows us to transform from the current UCS to WCS, e.g.:

wcsPoint = Acad.Editor.CurrentViewport.ucsToWorld(ucsPoint);

We only need to use this to transform the picked centre-point of the circle into WCS.

One thing I struggled with: I had trouble getting distance acquisition to work properly in an arbitrary UCS inside our jig, so I ended up ditching it in favour of acquiring a second point and then calculating the distance to the centre-point manually. Which is why we now have a distanceBetween() function that uses Pythagoras’ theorem to calculate the distance between two points.

No changes were needed to the C# code we saw last time (which is still needed), but here are the updates to the JavaScript code. Its CJ command should now work well in any User Coordinate System you can define inside AutoCAD:

var doc = Acad.Application.activedocument;

var center = new Acad.Point3d(0, 0, 0);

var ucsCenter;

var radius = 0;

var jig;

 

function pointToString(pt) {

  var ret =

    pt.x.toString() + "," +

    pt.y.toString() + "," +

    pt.z.toString();

  return ret;

}

 

function distanceBetween(pt1, pt2) {

  var dist =

    Math.sqrt(

      (pt2.x - pt1.x) * (pt2.x - pt1.x) +

      (pt2.y - pt1.y) * (pt2.y - pt1.y) +

      (pt2.z - pt1.z) * (pt2.z - pt1.z)

    );

  return dist;

}

 

function createCircle(cen, rad, first) {

 

  // Build an XML string containing data to create

  // an AcGiTransient that represents the circle

 

  var cursor = '';

 

  var drawable =

    '<?xml version="1.0" encoding="utf-8"?>' +

    '<drawable ' +

    'xmlns="http://www.autodesk.com/AutoCAD/drawstream.xsd" ' +

    'xmlns:t="http://www.autodesk.com/AutoCAD/transient.xsd" '+

      't:onmouseover="onmouseover"' + cursor + '>' +

      '<graphics id="id1"><circle center ="' + pointToString(cen) +

          '" radius ="' + rad.toString() + '"/>' +

      '</graphics></drawable>';

 

  return drawable;

}

 

function circleJig() {

 

  function onJigUpdate(args) {

 

    var res = JSON.parse(args);

    if (res) {

 

      // We calculate the distance in the WCS

      // (using distance input we'd just do this:

      //  radius = res.distance; )

 

      var point =

        new Acad.Point3d(res.point.x, res.point.y, res.point.z);

      radius = distanceBetween(center, point);

 

      // Use it to create the XML for a transient

      // circle and ask for it to be displayed

 

      //var x = createCircle(center, radius);

      //jig.update(x, onJigContinue, onJigError);

      drawCircle(center, radius);

    }

 

    return true;

  }

 

  function onJigComplete(args) {

 

    clearCircle();

 

    var res = JSON.parse(args);

    if (res && res.dragStatus == Acad.DragStatus.kNormal) {

 

      Acad.Editor.executeCommandAsync(

        '_.CIRCLE ' + pointToString(ucsCenter) + ' ' + radius

      );

    }

  }

 

  function onJigContinue(args) {

  }

 

  function onJigError(args) {

    clearCircle();

    write('\nUnable to create circle: ' + args);

  }

 

  function onPointSelected(args) {

 

    try {

      var res = JSON.parse(args);

      if (res) {

 

        // Extract and transform our circle's center

 

        ucsCenter =

          new Acad.Point3d(

            res.value.x,

            res.value.y,

            res.value.z

          );

        center = Acad.Editor.CurrentViewport.ucsToWorld(ucsCenter);

 

        // Draw the circle with an initial 0 radius

 

        drawCircle(center, 0);

 

        // Set up our jig options

 

        var opts =

          new Acad.JigPromptPointOptions('Point on radius');

        opts.userInputControls =

          Acad.UserInputControls.kAccept3dCoordinates;

 

        // Run the jig to select the distance

 

        jig = new Acad.DrawJig(onJigUpdate, opts);

        Acad.Editor.drag(jig).then(onJigComplete, onJigError);

      }

    }

    catch (ex) {

      write('\nException: ' + ex + '\n');

    }

  }

 

  function onPointError(args) {

    write('\nUnable to select point: ' + args);

  }

 

  // Ask the user to select the center point before we

  // start the jig

 

  var opts = new Acad.PromptPointOptions('Select center');

  Acad.Editor.getPoint(opts).then(

    onPointSelected, onPointError

  );

}

 

// Our extensions to the AutoCAD Shaping Layer

 

function drawCircle(cen, rad) {

  execAsync(

    JSON.stringify({

      functionName: 'NetDrawCircle',

      invokeAsCommand: false,

      functionParams: {

        center: cen,

        radius: rad

      }

    }),

    onInvokeSuccess,

    onInvokeError

  );

}

 

function clearCircle() {

  execAsync(

    JSON.stringify({

      functionName: 'NetClearCircle',

      invokeAsCommand: false,

      functionParams: undefined

    }),

    onInvokeSuccess,

    onInvokeError

  );

}

 

function onInvokeSuccess(result) {

  write("\n");

}

 

function onInvokeError(result) {

  write("\nOnInvokeError: " + result);

}

 

Acad.Editor.addCommand(

  "JIG_CMDS",

  "CJ",

  "CJ",

  Acad.CommandFlag.MODAL,

  circleJig

);

Complementing AutoCAD’s JavaScript API using .NET

After having some fun writing our first jig inside AutoCAD, last week, and calling it either from an HTML page or an AutoCAD command defined in a .js file, in today’s post we’re going to see how we can use AutoCAD’s .NET API to extend its new JavaScript layer.

We’re going to take a concrete problem we had in last week’s implementation: it turns out that when you draw a transient circle beneath the cursor using JavaScript – as we do during our jig – it absorbs mouse clicks. This is something we’ve logged as an issue, but it seems an interesting problem to work around using the extensibility framework we’ve built into AutoCAD’s JavaScript API. It’s always nice to have a concrete problem to get your teeth into. :-)

For some background to both the extensibility mechanism and AutoCAD’s JavaScript implementation, I recommend taking a look at Philippe Leefsma’s DevTV recording over on the AutoCAD DevBlog. The provided downloadable archive includes demos that show how to complement the JavaScript API using either ObjectARX or .NET.

So what do we want to do to work around our problem? Well, rather than drawing the transient graphics directly in JavaScript, we’re going to define a couple of methods in .NET that will get called from our JavaScript code via some functions that implement the required data marshaling.

Firstly, we need a drawCircle() function that draws a circle with the provided center and radius. The first time it’s called, this function will create a Circle and keep it in memory for subsequent calls. We also need a clearCircle() function both to remove the transient graphics and to dispose of the Circle object (otherwise there’ll be a crash when the object is disposed of by the .NET finalizer, which works on a background thread).

Let’s start with the C# implementation code. This code needs to be compiled into a DLL and then NETLOADed into AutoCAD for all this to work, of course:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.GraphicsInterface;

using Autodesk.AutoCAD.Runtime;

using Newtonsoft.Json.Linq;

 

namespace JavaScriptExtender

{

  public class Functions

  {

    private static Circle _cir = null;

 

    [JavaScriptCallback("NetDrawCircle")]

    public string DrawCircle(string jsonArgs)

    {

      // Unpack our JSON-encoded parameters using Json.NET

 

      var o = JObject.Parse(jsonArgs);

      var x = (double)o["functionParams"]["center"]["x"];

      var y = (double)o["functionParams"]["center"]["y"];

      var z = (double)o["functionParams"]["center"]["z"];

      var center = new Point3d(x, y, z);

      var radius = (double)o["functionParams"]["radius"];

 

      // Draw our transient circle

 

      var ic = new IntegerCollection();

      var tm = TransientManager.CurrentTransientManager;

      if (_cir == null)

      {

        // If the first time, create our circle

 

        var ed =

          Application.DocumentManager.MdiActiveDocument.Editor;

        var norm =

          ed.CurrentUserCoordinateSystem.CoordinateSystem3d.Zaxis;

        _cir = new Circle(center, norm, radius);

 

        // And then draw it

 

        tm.AddTransient(_cir, TransientDrawingMode.Main, 0, ic);

      }

      else

      {

        // If not the first time, update our circle and

        // the transient graphics representation of it

 

        _cir.Center = center;

        _cir.Radius = radius;

        tm.UpdateTransient(_cir, ic);

      }

      return "{\"retCode\":0, \"result\":\"OK\"}";

    }

 

    [JavaScriptCallback("NetClearCircle")]

    public string ClearCircle(string jsonArgs)

    {

      if (_cir != null)

      {

        // Clear the transient graphics we've added

 

        var ic = new IntegerCollection();

        var tm = TransientManager.CurrentTransientManager;

        tm.EraseTransient(_cir, ic);

 

        // Very importantly dispose of our Circle

 

        _cir.Dispose();

        _cir = null;

      }

      return "{\"retCode\":0, \"result\":\"OK\"}";

    }

  }

}

You’ll notice that the two methods we want to call from JavaScript – DrawCircle() and ClearCircle() – are tagged with the custom JavaScriptCallback attribute.

Something else to note is that the arguments passed into these methods are packaged as JSON (although this will be null for ClearCircle() as it doesn’t take logical arguments – we’ll see that later) that we’ll therefore need to unpack. In the first function, we do this using Newtonsoft’s excellent Json.NET library.

The simple way to add Json.NET to your project is via NuGet. In the Visual Studio interface select Tools –> Library Package Manager –> Manage NuGet Packages for Solution…

Check the beginning of the DrawCircle() method to see how Json.NET helps us unpack the JSON that’s passed into the function.

That’s the .NET side of things: now let’s take a look at what we need to add to our JavaScript code to essentially extend the JavaScript Shaping Layer.

Here’s the updated JavaScript code – the standalone version we saw at the end of last week. We could also update the HTML palette, but that would take more work to marshal across the data set by its various UI elements.

var doc = Acad.Application.activedocument;

var center = new Acad.Point3d(0, 0, 0);

var radius = 0;

//var trId;

 

function pointToString(pt) {

  var ret =

    pt.x.toString() + "," +

    pt.y.toString() + "," +

    pt.z.toString();

  return ret;

}

 

function createCircle(cen, rad, first) {

 

  // Build an XML string containing data to create

  // an AcGiTransient that represents the circle

 

  var cursor = '';

 

  var drawable =

    '<?xml version="1.0" encoding="utf-8"?>' +

    '<drawable ' +

    'xmlns="http://www.autodesk.com/AutoCAD/drawstream.xsd" ' +

    'xmlns:t="http://www.autodesk.com/AutoCAD/transient.xsd" '+

      't:onmouseover="onmouseover"' + cursor + '>' +

      '<graphics id="id1"><circle center ="' + pointToString(cen) +

          '" radius ="' + rad.toString() + '"/>' +

      '</graphics></drawable>';

 

  return drawable;

}

 

function circleJig() {

 

  function onJigUpdate(args) {

 

    var res = JSON.parse(args);

    if (res) {

 

      // The value being updated is the distance

 

      radius = res.distance;

 

      // Use it to create the XML for a transient

      // circle and ask for it to be displayed

 

      //var x = createCircle(center, radius);

      //doc.transientManager.updateTransient(trId, x);     

      drawCircle(center, radius);

    }

 

    return true;

  }

 

  function onJigComplete(args) {

 

    // When the jig is over, remove the transient

 

    //doc.transientManager.eraseTransient(trId);

    clearCircle();

 

    var res = JSON.parse(args);

    if (res && res.dragStatus == Acad.DragStatus.kNormal) {

 

      Acad.Editor.executeCommandAsync(

        '_.CIRCLE ' + pointToString(center) + ' ' + radius

      );

    }

  }

 

  function onJigError(args) {

    write('\nUnable to create circle: ' + args);

  }

 

  function onPointSelected(args) {

 

    var res = JSON.parse(args);

    if (res) {

      center =

        new Acad.Point3d(

          res.value.x,

          res.value.y,

          res.value.z

        );

 

      // Now we can create our transient

 

      //var tran = new Acad.Transient();

      //trId = tran.getId();

 

      // And ask for it to be drawn

 

      //var x = createCircle(center, 0, true);

      //doc.transientManager.addTransient(tran, x);

      drawCircle(center, 0);

 

      // Set up our jig options

 

      var opts =

        new Acad.JigPromptDistanceOptions('Point on radius');

      opts.basePoint = center;

      opts.useBasePoint = true;

 

      // Run the jig to select the distance

 

      var jig = new Acad.DrawJig(onJigUpdate, opts);

      Acad.Editor.drag(jig).then(onJigComplete, onJigError);

    }

  }

 

  function onPointError(args) {

    write('\nUnable to select point: ' + args);

  }

 

  // Ask the user to select the center point before we

  // start the jig

 

  var opts = new Acad.PromptPointOptions('Select center');

  Acad.Editor.getPoint(opts).then(

    onPointSelected, onPointError

  );

}

 

// Our extensions to the AutoCAD Shaping Layer

 

function drawCircle(cen, rad) {

  execAsync(

    JSON.stringify({

      functionName: 'NetDrawCircle',

      invokeAsCommand: false,

      functionParams: {

        center: cen,

        radius: rad

      }

    }),

    onInvokeSuccess,

    onInvokeError

  );

}

 

function clearCircle() {

  execAsync(

    JSON.stringify({

      functionName: 'NetClearCircle',

      invokeAsCommand: false,

      functionParams: undefined

    }),

    onInvokeSuccess,

    onInvokeError

  );

}

 

function onInvokeSuccess(result) {

  write("\n");

}

 

function onInvokeError(result) {

  write("\nOnInvokeError: " + result);

}

 

Acad.Editor.addCommand(

  "JIG_CMDS",

  "CJ",

  "CJ",

  Acad.CommandFlag.MODAL,

  circleJig

);

I’ve commented out the various uses of transient graphics (although I’ve left in the now-unused createCircle() function) so you can contrast the calls with the new ones to drawCircle() and clearCircle().

It should be fairly obvious how we’ve implemented our drawCircle() and clearCircle() functions to simply call through to .NET using execAsync() (I suppose exec() might also have been called, but I tend to prefer to use asynchronous calls unless it’s absolutely required to use synchronous ones).

If you’d like to give this version a try – and it seems to work very well for me, at least – copy & paste the following into the command-line of AutoCAD 2014:

(command "_.WEBLOAD" "http://through-the-interface.typepad.com/files/CircleJigNet.js")

As mentioned earlier, you’ll need to have built the post’s C# code into a DLL that you NETLOAD into AutoCAD before the JavaScript code will function correctly. This will clearly impact the portability of your JavaScript code – unless you add the same capability across the other (future) platforms – but hopefully you can see how it’s possible to extend our JavaScript API implementation when you really need to.

Jigging an AutoCAD circle from a JavaScript-defined command

Just to complement yesterday’s post showing how to define a simple jig using JavaScript, here’s the same code from a separate .js file:

var doc = Acad.Application.activedocument;

var center = new Acad.Point3d(0, 0, 0);

var radius = 0;

var trId;

 

function pointToString(pt) {

  var ret =

    pt.x.toString() + "," +

    pt.y.toString() + "," +

    pt.z.toString();

  return ret;

}

 

function createCircle(cen, rad, first) {

 

  // Build an XML string containing data to create

  // an AcGiTransient that represents the circle

 

  var cursor = '';

 

  var drawable =

    '<?xml version="1.0" encoding="utf-8"?>' +

    '<drawable ' +

    'xmlns="http://www.autodesk.com/AutoCAD/drawstream.xsd" ' +

    'xmlns:t="http://www.autodesk.com/AutoCAD/transient.xsd" '+

      't:onmouseover="onmouseover"' + cursor + '>' +

      '<graphics id="id1"><circle center ="' + pointToString(cen) +

          '" radius ="' + rad.toString() + '"/>' +

      '</graphics></drawable>';

 

  return drawable;

}

 

function circleJig() {

 

  function onJigUpdate(args) {

 

    var res = JSON.parse(args);

    if (res) {

 

      // The value being updated is the distance

 

      radius = res.distance;

 

      // Use it to create the XML for a transient

      // circle and ask for it to be displayed

 

      var x = createCircle(center, radius);

      doc.transientManager.updateTransient(trId, x);

    }

 

    return true;

  }

 

  function onJigComplete(args) {

 

    // When the jig is over, remove the transient

 

    doc.transientManager.eraseTransient(trId);

 

    var res = JSON.parse(args);

    if (res && res.dragStatus == Acad.DragStatus.kNormal) {

 

      Acad.Editor.executeCommandAsync(

        '_.CIRCLE ' + pointToString(center) + ' ' + radius

      );

    }

  }

 

  function onJigError(args) {

    write('\nUnable to create circle: ' + args);

  }

 

  function onPointSelected(args) {

 

    var res = JSON.parse(args);

    if (res) {

      center =

        new Acad.Point3d(

          res.value.x,

          res.value.y,

          res.value.z

        );

 

      // Now we can create our transient

 

      var tran = new Acad.Transient();

      trId = tran.getId();

 

      // And ask for it to be drawn

 

      var x = createCircle(center, 0, true);

      doc.transientManager.addTransient(tran, x);

 

      // Set up our jig options

 

      var opts =

        new Acad.JigPromptDistanceOptions('Point on radius');

      opts.basePoint = center;

      opts.useBasePoint = true;

 

      // Run the jig to select the distance

 

      var jig = new Acad.DrawJig(onJigUpdate, opts);

      Acad.Editor.drag(jig).then(onJigComplete, onJigError);

    }

  }

 

  function onPointError(args) {

    write('\nUnable to select point: ' + args);

  }

 

  // Ask the user to select the center point before we

  // start the jig

 

  var opts = new Acad.PromptPointOptions('Select center');

  Acad.Editor.getPoint(opts).then(

    onPointSelected, onPointError

  );

}

 

Acad.Editor.addCommand(

  "JIG_CMDS",

  "CJ",

  "CJ",

  Acad.CommandFlag.MODAL,

  circleJig

);

You can test this without the need for a separate .NET loader by just copying this into the command-line in AutoCAD 2014:

(command "_.WEBLOAD" "http://through-the-interface.typepad.com/files/CircleJig.js")

Then you should be able to run the CJ command to jig a circle from JavaScript.

Again, you’ll see the issue related to clicking the point on the radius (unless it’s system-specific, which would surprise me a great deal), but it’ll give you a sense of the kind of responsiveness to expect from a JavaScript-implemented jig.

On a general note, I’ve been finding that it’s simplest to code within a full HTML page – as the reference to the AutoCAD Shaping Layer JavaScript file gives more useful IntelliSense. It does mean you need a .NET loader module to test, but once you have it set up, it’s there. What’s also very handy about this approach is that each time the loader command (in my case it’s called JSP) is run, it reloads the palette from wherever it’s located. So you can change the code and re-run the loader command without restarting AutoCAD (something that’s really entered into muscle memory after all these years of developing with .NET and not having Edit & Continue). One caveat to this is if your code causes the AcWebBrowser to crash: if that’s the case (and it’s pretty common, at least with my code ;-) then you’ll need to restart AutoCAD.

I also tend to load the HTML page from the local file system (using a URL such as  “file://C:\Path\To\MyPalette.html” in the loader module), as this avoids the pain of having to push it to a web-server and deal with the caching issues when loading. It may not have been obvious from prior posts that you can load from a local file system, so I should confirm that it’s possible and furthermore works very well.

In terms of debugging, I’ve been using the technique shown in Fenton’s very handy blog post to enable some level of debugging of HTML-defined palettes (another advantage over a separate .js loaded via WEBLOAD). The server that hosts the HTML inspector tool has changed, however – the URL needs to be changed to “http://drawingfeed.visualtao.net/DevTools/inspector/devtools.html” – but I’m sure the DevBlog post will be updated soon (and may well have been by the time many of you end up reading this).

That said, I still find I’m inserting lots of write() statements into my code (which causes messages to be written to the AutoCAD command-line, the equivalent of acutPrintf() or Editor.WriteMessage()). Maybe that’s another bit of (this time web-development focused) muscle memory that I’ve retained in spite of the world having moved on, but I find it’s a quick enough way of working out what’s going on in the code. Once I get around to using more capabilities provided by the JavaScript debugger, I’ll hopefully find I can afford to unlearn this particular behaviour, but then the fact the debugger also gets blown away when AcWebBrowser crashes means there are a lot of scenarios that write() is still better suited to report on.

Jigging an AutoCAD circle using JavaScript

After talking about the architecture of our JavaScript API in this recent post – and mentioning the approach we expect developers to take when creating geometry in one of the comments – I thought it would be worth spending the time to write my first JavaScript jig in AutoCAD.

For those of you who haven’t come across jigs in either ObjectARX or AutoCAD .NET, jigs are the primary way applications request users to dynamically specify geometric parameters while providing them with graphical feedback. As users select points or specify distances, the object or objects they’re creating are updated in real-time to reflect these choices. Much as you’d use a standard AutoCAD command to create geometry.

If you want to define a jig for a single object using .NET, you’ll probably use an EntityJig. The other main type of jig – a DrawJig – is not bound to a single object, although it can be used to create one. It basically allows the application to decide what gets drawn, rather than calling a particular object’s drawing methods.

Given the fact the JavaScript API doesn’t provide access to AutoCAD drawing objects – and there are currently no plans to provide this access – it made sense to expose the DrawJig capability to JavaScript. This allows applications to display custom, transient graphics during the jig’s operation, and then fire one or more AutoCAD commands to generate the drawing object(s) once done. Given there’s some IPC needed to communicated between the process hosting JavaScript and AutoCAD, you clearly don’t want to be marshaling huge objects (such as we saw in this recent post): not only would the XML generated to communicate the transient graphics to be displayed be large, so would the command-string you’d need to compose and send to generate the final database-resident representation.

So with that in mind, I set about creating what’s probably the simplest of jigs: to create a circle at a given point, asking the user to select the radius.

Here’s the JavaScript code I created, embedded into an HTML page to be loaded into a palette, based on the one we saw in this previous post:

<html>

  <head>

    <title>Jig a circle</title>

    <script

      type="text/javascript"

      src="http://www.autocadws.com/jsapi/v1/Autodesk.AutoCAD.js">

    </script>

    <script type="text/javascript">

 

      var doc = Acad.Application.activedocument;

      var center = new Acad.Point3d(0, 0, 0);

      var radius = 0;

      var trId;

 

      var colors = new Array();

      colors['Red'] = "#ff0000";

      colors['Yellow'] = "#ffff00";

      colors['Green'] = "#00ff00";

      colors['Cyan'] = "#00ffff";

      colors['Blue'] = "#0000ff";

      colors['Magenta'] = "#ff00ff";

      colors['White'] = "#ffffff";

 

      function pointToString(pt) {

        var ret =

          pt.x.toString() + "," +

          pt.y.toString() + "," +

          pt.z.toString();

        return ret;

      }

 

      function createCircle(cen, rad, first) {

 

        // Build an XML string containing data to create

        // an AcGiTransient that represents the circle

 

        var props = '';

        var cursor = '';

 

        if (first != true) {

 

          var color = document.getElementById('ColCB').value;

          var linetype = document.getElementById('LTCB').value;

          var lineweight = document.getElementById('LWCB').value;

          var filled = document.getElementById('Filled').checked;

          props =

            'color="' + colors[color] +

            '" lineweight="' + lineweight +

            '" linetype="' + linetype +

            '" filled="' + filled + '"';

          var cursorType = document.getElementById('Cursor').value;

          if (cursorType == 'None')

            cursor = '';

          else

            cursor = ' cursor="' + cursorType + '"';

        }

 

        var drawable =

          '<?xml version="1.0" encoding="utf-8"?>' +

          '<drawable ' +

          'xmlns="http://www.autodesk.com/AutoCAD/drawstream.xsd" ' +

          'xmlns:t="http://www.autodesk.com/AutoCAD/transient.xsd" '+

            't:onmouseover="onmouseover"' + cursor + '>' +

            '<graphics id="id1" ' + props + '>' +

              '<circle center ="' + pointToString(cen) +

                '" radius ="' + rad.toString() + '"/>' +

            '</graphics></drawable>';

 

        return drawable;

      }

 

      function circleJig() {

 

        function onJigUpdate(args) {

 

          var res = JSON.parse(args);

          if (res) {

 

            // The value being updated is the distance

 

            radius = res.distance;

 

            // Use it to create the XML for a transient

            // circle and ask for it to be displayed

 

            var x = createCircle(center, radius);

            doc.transientManager.updateTransient(trId, x);

          }

 

          return true;

        }

 

        function onJigComplete(args) {

 

          // When the jig is over, remove the transient

 

          doc.transientManager.eraseTransient(trId);

 

          var res = JSON.parse(args);

          if (res && res.dragStatus == Acad.DragStatus.kNormal) {

 

            Acad.Editor.executeCommandAsync(

              '_.CIRCLE ' + pointToString(center) + ' ' + radius

            );

          }

        }

 

        function onJigError(args) {

          write('\nUnable to create circle: ' + args);

        }

 

        function onPointSelected(args) {

 

          var res = JSON.parse(args);

          if (res) {

            center =

              new Acad.Point3d(

                res.value.x,

                res.value.y,

                res.value.z

              );

 

            // Now we can create our transient

 

            var tran = new Acad.Transient();

            trId = tran.getId();

 

            // And ask for it to be drawn

 

            var x = createCircle(center, 0, true);

            doc.transientManager.addTransient(tran, x);

 

            // Set up our jig options

 

            var opts =

              new Acad.JigPromptDistanceOptions('Point on radius');

            opts.basePoint = center;

            opts.useBasePoint = true;

 

            // Run the jig to select the distance

 

            var jig = new Acad.DrawJig(onJigUpdate, opts);

            Acad.Editor.drag(jig).then(onJigComplete, onJigError);

          }

        }

 

        function onPointError(args) {

          write('\nUnable to select point: ' + args);

        }

 

        // Ask the user to select the center point before we

        // start the jig

 

        var opts = new Acad.PromptPointOptions('Select center');

        Acad.Editor.getPoint(opts).then(

          onPointSelected, onPointError

        );

      }

 

    </script>

 

    <style type="text/css">

      td, body

        { font-family: sans-serif; font-size: 10pt; }

      body

        { background-color: #686868;

          padding:0;

          margin:5px 5px 5px 5px;

          color:#FFF; }

      textarea

        { font-family: Consolas; font-size: 8pt; }

    </style>

  </head>

  <body>

    <div id="canvas" class="shadow_box">

      <h3>Jig a circle</h3>

      <table border="0">

        <tr>

          <td align='right'>Color</td>

          <td>

            <select id='ColCB'>

              <option selected="selected">Red</option>

              <option>Yellow</option>

              <option>Green</option>

              <option>Cyan</option>

              <option>Blue</option>

              <option>Magenta</option>

              <option>White</option>

            </select>

          </td>

        </tr>

        <tr>

          <td align='right'>LineType</td>

          <td>

            <select id='LTCB'>

              <option selected="selected">LineTypeSolid</option>

              <option>Dashed</option>

              <option>Dotted</option>

              <option>Dash_Dot</option>

              <option>Short_Dash</option>

              <option>Medium_Dash</option>

              <option>Long_Dash</option>

              <option>Short_Dash_X2</option>

              <option>Medium_Dash_X2</option>

              <option>Long_Dash_X2</option>

              <option>Medium_Long_Dash</option>

              <option>Medium_Dash_Short_Dash_Short_Dash</option>

              <option>Long_Dash_Short_Dash</option>

              <option>Long_Dash_Dot_Dot</option>

              <option>Long_Dash_Dot</option>

              <option>Medium_Dash_Dot_Short_Dash_Dot</option>

              <option>Sparse_Dot</option>

              <option>Solid_6_Pixels_Blank_6_Pixels</option>

            </select>

          </td>

        </tr>

        <tr>

          <td align='right'>LineWeight</td>

          <td>

            <select id='LWCB'>

              <option>0</option>

              <option>5</option>

              <option>9</option>

              <option>13</option>

              <option>15</option>

              <option>18</option>

              <option>20</option>

              <option>25</option>

              <option selected="selected">30</option>

              <option>35</option>

              <option>40</option>

              <option>50</option>

              <option>53</option>

              <option>60</option>

              <option>70</option>

              <option>80</option>

              <option>90</option>

              <option>100</option>

              <option>106</option>

              <option>120</option>

              <option>140</option>

              <option>158</option>

              <option>200</option>

              <option>211</option>

            </select>

          </td>

        </tr>

        <tr>

          <td align='right'>Filled</td>

          <td>

            <input type='checkbox' id='Filled'/>

          </td>

        </tr>

        <tr>

          <td align='right'>Cursor</td>

          <td>

            <select

              id='Cursor'

              title='Cursor to be displayed on hover'>

              <option selected="selected">None</option>

              <option>None</option>

              <option>Arrow</option>

              <option>Ibeam</option>

              <option>Wait</option>

              <option>Cross</option>

              <option>UpArrow</option>

              <option>SizeNWSE</option>

              <option>SizeNESW</option>

              <option>SizeWE</option>

              <option>SizeNS</option>

              <option>SizeAll</option>

              <option>No</option>

              <option>Hand</option>

              <option>AppStarting</option>

              <option>Help</option>

            </select>

          </td>

        </tr>

        <tr>

          <th>&nbsp;</th>

          <td>

            <input

              type='button'

              onclick='circleJig()'

              value='Jig Circle' />

          </td>

        </tr>

      </table>

    </div>

  </body>

</html>

When we load and run the palette – using the same .NET loader we saw in the post that first showed how to implement a palette using JavaScript – we see we can use it to launch our jig and create circles. Bear in mind that the settings in the palette are only respected during the jig: the CIRCLE command will simply pick up the current layer, linetype etc. when it creates the final circle.

The jig doesn’t operate as smoothly as you’d expect it to from ObjectARX or .NET, but then there is some marshaling overhead involved, after all. You’ll have to weigh the trade-offs between (future) portability, development effort and performance. (It’s also not clear it’s easier to develop using JavaScript than .NET… it’s probably easier than C++ but the tools available to debug your JavaScript code are still not that great).

Also, I found some trickiness when selecting the point to terminate the jig which then causes the command to be launched inside AutoCAD. If we comment out the code to display transient graphics it works perfectly, but otherwise you may have to click a few times to make it work. This is something that requires some further research – it feels as though some messages are getting swallowed, but it could be due to something else entirely.

Anyway, this is to say that there are still some rough edges around this API, which is natural given its relative age. My recommendation is to play around with it, but not to over-invest just yet: use the opportunity to get familiar with the tools and technology, and you’ll hopefully see us make the experience smoother over the next few releases.

Call for proposals: Autodesk University 2013

I arrived back safely in Switzerland on Saturday night. It was a pretty good trip to the Bay Area, this time: most surprisingly this is the first time ever I’ve managed to sleep through until 6am (or thereabouts) on every single day of a trip to California.

But then I – like many people – do find going west to be easier than going east, jetlag-wise. I certainly found that I couldn’t get back to sleep when I woke up at home on Sunday morning at 3am, which made for a very long day (especially as we participated in the “Slow Up” event around a local lake, which – for me – meant pedaling along, pulling my youngest two children in a bicycle trailer for 30+ km). At least that meant I slept very soundly through the second night back, for which I’m thankful. Let’s see how I suffer when I head eastwards to Singapore in a couple of short weeks.

As many of you will now be aware, the call for proposals for AU 2013 is now open and will remain so until May 19th. It’s always great to have people presenting fresh ideas at the conference, so think about whether you have something to share with fellow Autodesk customers/partners/developers and submit a proposal or two!

I have another deadline, around the time the call for proposals closes, to provide presentation material on integrating both Leap Motion and Kinect Fusion into AutoCAD – to be presented in early June at our annual, internal Technical Summit in Boston (the third of my long-haul flights in the coming weeks) – so these are very likely to be the topics I submit for consideration for this year’s AU. At least that hopefully means – assuming the sessions are accepted and I get to attend – my lead-up to AU 2013 will not be as frantic as it sometimes is.

All this now means I’m back looking at both of these technologies, downloading the latest Leap Motion SDK and seeing whether I can tweak a little more performance out of the Kinect Fusion runtime to make it run more smoothly. I’ll certainly present whatever I manage to uncover (that I consider to be of interest) during the coming days.

Stripping formatting from AutoCAD tables pasted from Excel using .NET

I’m back in San Rafael after a tiring – but very rewarding – two days down in Santa Cruz. I’ve decided to rattle out a quick post – inspired by this recent comment – before heading out for dinner, so I hope my brain isn’t playing tricks on me when it says the code’s good enough to post. Please do let me know if you see anything wrong with it.

Here’s the question:

Kean, I am wondering how to do this on table objects. When importing a table from excel as pasting special ACAD objects, you can reset the table overrides, but this does not reset the cell content. You manually have to go through each cell to reset the formatting of the content. I have written an app that iterates through the selected table's rows/columns and gets the content in an attempt to use the text editor to reset the content of each cell. However, the texteditor.create only allows for MTEXT in which the table content is not MTEXT. I've looked on your other blog posts on tables and don't see a way to do this. Please help if you can. Thanks. Steve

When we run the PASTESPEC command – with some Excel data in the clipboard – and choose to insert “AutoCAD entities”, we get an AutoCAD table containing formatted text that shows up as black:

If we look at the contents of a particular cell, we see it has embedded formatting codes, such as this: "{\\fCalibri|b0|i0|c0;\\c0;A"

To remove this formatting, I adopted the technique suggested by Tony Tanzillo in an earlier comment on that post – and that I’ve looked at in some depth in this other post – to get at each cell’s unformatted contents. The code uses an MText object to strip off the formatting rather than the MText editor.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

 

namespace TableFormatting

{

  public class Commands

  {

    [CommandMethod("STF")]

    public static void StripTableFormatting()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      // Ask the user to select a table

 

      var peo = new PromptEntityOptions("\nSelect table");

      peo.SetRejectMessage("\nMust be a table.");

      peo.AddAllowedClass(typeof(Table), false);

      peo.AllowNone = false;

      var per = ed.GetEntity(peo);

      if (per.Status != PromptStatus.OK)

        return;

 

      var tabId = per.ObjectId;

 

      using (var tr = doc.TransactionManager.StartTransaction())

      {

        // Open the table for write

 

        var tab = tr.GetObject(tabId, OpenMode.ForWrite) as Table;

        if (tab == null)

          return;

 

        // Start by clearing any style overrides

 

        tab.Cells.ClearStyleOverrides();

 

        // We'll use an MText object to strip embedded formatting

 

        using (var mt = new MText())

        {

          for (int r = 0; r < tab.Rows.Count; r++)

          {

            for (int c = 0; c < tab.Columns.Count; c++)

            {

              // Get the cell and its contents

 

              var cell = tab.Cells[r, c];

              mt.Contents = cell.TextString;

 

              // Explode the text fragments

 

              mt.ExplodeFragments(

                (a, b) =>

                {

                  if (a != null)

                  {

                    // Assuming we have a fragment, use its text

                    // to set the cell contents

 

                    cell.TextString = a.Text;

                  }

                  return MTextFragmentCallbackStatus.Continue;

                }

              );

            }

          }

        }

        tr.Commit();

      }

    }

  }

}

Sure enough, we can run the STF command and select our table to strip away its formatting:

Show me the money!

Or otherwise named “Creating an AutoCAD jig to dynamically display a guilloché pattern using F#”. But then why pass up the chance for a Jerry Maguire reference? :-)

Anyway, to continue on from last week’s post, Doug – who had presented the original challenge – went on to suggest that I give it the same treatment as Spiro. Basically to implement a jig to display the guilloche pattern dynamically as you input the various options.

I understand the difficulty in understanding the nature of the geometry being created in the previous version… the fact that I’d named the original variables R, r, p, Q, m and n (as per the equation in the post that inspired this app) probably didn’t help with the understandability of the app, all things considered. It was certainly easier to name the various parameters in that way rather than work out more human-friendly labels.

This time around, though, I found additional help from this site, which includes a very cool Flash-based guilloché configurator. And as it also provided source code, I was able to connect some of the exposed UI elements with the underlying formula.

Which has given rise to this version of the app, with an additional GUIJIG command to complement GUILLOCHE. We’re also now storing the previous selections – whether via the jig- or the prompt-based version – so there’s an accompanying GUIDEF command to reset these default values should they become confused or confusing (and that’s quite easy to do with this app).

So here’s the updated F# code. Bear in mind this is still very much in the experimental stage, so expect quirks. If you have some ideas on how to improve it (such as an alternative name for the “Wiggle” parameter :-) then please let me know.

module Guillocher.Commands

 

open Autodesk.AutoCAD.ApplicationServices.Core

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open System

 

// Save our various default values in mutable state

 

let mutable _R = 50.0

let mutable _r = -0.2

let mutable _p = 25.0

let mutable _Q = 3.0

let mutable _m = 1.0

let mutable _n = 6.0

let mutable _segs = 300

let mutable _perfSegs = 1000

 

// User prompting helper functions

 

let getIntegerWithDefault (ed : Editor) msg min max def =

  let pio = new PromptIntegerOptions(msg)

  pio.LowerLimit <- min

  pio.UpperLimit <- max

  pio.DefaultValue <- def

  pio.UseDefaultValue <- true

 

  let pir = ed.GetInteger(pio)

  if pir.Status = PromptStatus.OK then

    Some(pir.Value)

  else

    None

 

let getDoubleWithDefault (ed : Editor) msg neg zero def =

  let pdo = new PromptDoubleOptions(msg)

  pdo.AllowNegative <- neg

  pdo.AllowZero <- zero

  pdo.DefaultValue <- def

  pdo.UseDefaultValue <- true

 

  let pdr = ed.GetDouble(pdo)

  if pdr.Status = PromptStatus.OK then

    Some(pdr.Value)

  else

    None

 

// Get the various values we need from the user for this command

 

let getGuillocheInput ed =

  let R = getDoubleWithDefault ed "\nR" true false _R

  if R = None then

    None

  else

    let r = getDoubleWithDefault ed "\nr" true false _r

    if r = None then

      None

    else

      let p = getDoubleWithDefault ed "\np" true false _p

      if p = None then

        None

      else

        let Q = getDoubleWithDefault ed "\nQ" true true _Q

        if Q = None then

          None

        else

          let m = getDoubleWithDefault ed "\nm" true false _m

          if m = None then

            None

          else

            let n = getDoubleWithDefault ed "\nn" true false _n

            if n = None then

              None

            else

              let segs =

                getIntegerWithDefault

                  ed "\nNumber of control points" 500 32767 _segs

              if segs = None then

                None

              else

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

                if ppr.Status = PromptStatus.OK then

 

                  // Set the selected values as our new defaults

                  // (stored in mutable global state)

 

                  _R <- R.Value

                  _r <- r.Value

                  _p <- p.Value

                  _Q <- Q.Value

                  _m <- m.Value

                  _n <- n.Value

                  _segs <- segs.Value

 

                  // Return these to the calling function for it to

                  // create the guilloche

 

                  Some(R, r, p, Q, m, n, segs, ppr.Value)

                else

                  None

 

let pointsOnGuilloche (cen : Point3d)  R r p Q m n segs =

  [|

    let period = Math.PI * 2.0;

    for theta in 0.0..period/(float segs)..period do

 

      let rr = R + r

      let rp = r + p

      let rror = rr / r

      let mth = m * theta

      let nth = n * theta

      let k = rror * mth

      let x =

        rr * Math.Cos(mth) + rp * Math.Cos(k) + Q * Math.Cos(nth)

      let y =

        rr * Math.Sin(mth) - rp * Math.Sin(k) + Q * Math.Sin(nth)

 

      yield cen + new Vector3d(x, y, 0.0)

  |]

 

// Different modes of acquisition for our jig

 

type AcquireMode =

  | RADIUS

  | MAJOR

  | MINOR

  | MULTIPLIER

  | WIGGLE

 

type GuillocheJig() as this = class

  inherit DrawJig()

 

  // Our mutable member state

 

  let mutable (_sp : Spline) = new Spline()

  let mutable _cen = Point3d.Origin

  let mutable _norm = Vector3d.ZAxis

  let mutable _locp = _p

  let mutable _locR = _R

  let mutable _locr = _r

  let mutable _locQ = _Q

  let mutable _locm = _m

  let mutable _mode = RADIUS

 

  // Calculate some ratios, so that we keep proportions

  // as we jig the initial values

 

  let _rOverP = _r / _p

  let _ROverP = _R / _p

  let _rOverR = _r / _R

 

  member x.StartJig(ed : Editor, pt) =

 

    // Set our center and start with the radius

 

    _cen <- pt

    _mode <- RADIUS

    _norm <- ed.CurrentUserCoordinateSystem.CoordinateSystem3d.Zaxis

 

    let stat = ed.Drag(this)

    if stat.Status = PromptStatus.OK then

 

      // Next we get the major ripple

 

      _mode <- MAJOR

      let stat = ed.Drag(this)

      if stat.Status = PromptStatus.OK then

 

        // Next the minor ripple

 

        _mode <- MINOR

        let stat = ed.Drag(this)       

        if stat.Status = PromptStatus.OK then

 

          // Next the angle multiplier

 

          _mode <- MULTIPLIER

          let stat = ed.Drag(this)       

          if stat.Status = PromptStatus.OK then

 

            // Next the wiggle

 

            _mode <- WIGGLE

            ed.Drag(this)

          else

            stat

        else

          stat

      else

        stat

    else

      stat

 

  // Helper function to acquire a distance and return

  // the appropriate status

 

  member private x.GetDist (prompts : JigPrompts)

    (opts : JigPromptDistanceOptions) oldVal =

 

    opts.DefaultValue <- oldVal

    let res = prompts.AcquireDistance(opts)

    if res.Status <> PromptStatus.OK then

      (SamplerStatus.Cancel, 0.0)

    else

      if oldVal = res.Value then

        (SamplerStatus.NoChange, 0.0)

      else

        (SamplerStatus.OK, res.Value)

 

  // Our Sampler function to acquire the various distances

 

  override x.Sampler prompts =

 

    // We're just acquiring distances

 

    let jo = new JigPromptDistanceOptions()

    jo.BasePoint <- _cen

    jo.Cursor <- CursorType.RubberBand

    jo.UseBasePoint <- true

    jo.UserInputControls <-

      UserInputControls.NoZeroResponseAccepted

 

    // Then we have slightly different behavior depending

    // on the info we're acquiring

 

    match _mode with

 

    // p...

 

    | RADIUS ->

      jo.Message <- "\nRadius"

      let (stat, res) = x.GetDist prompts jo _locp

      if stat = SamplerStatus.OK then

        _locp <- res

      stat

 

    // R...

 

    | MAJOR ->

      jo.Message <- "\nMajor ripple"

      let (stat, res) = x.GetDist prompts jo _locR

      if stat = SamplerStatus.OK then

        _locR <- res

      stat

 

    // r...

 

    | MINOR ->

      jo.Message <- "\nMinor ripple"

      let (stat, res) = x.GetDist prompts jo _locr

      if stat = SamplerStatus.OK then

        _locr <- res

      stat

 

    // m...

 

    | MULTIPLIER ->

      jo.Message <- "\nAngle multiplier"

      let (stat, res) = x.GetDist prompts jo _locm

      if stat = SamplerStatus.OK then

        _locm <- res

      stat

 

    // Q...

 

    | WIGGLE ->

      jo.Message <- "\nWiggle"

      let (stat, res) = x.GetDist prompts jo _locQ

      if stat = SamplerStatus.OK then

        _locQ <- res

      stat

 

  // Our WorldDraw function to display the guilloche and

  // the related temporary graphics

 

  override x.WorldDraw

    (draw : Autodesk.AutoCAD.GraphicsInterface.WorldDraw) =

 

    // We'll actually only draw a green circle for our radius

 

    if _mode = RADIUS then

      let col = draw.SubEntityTraits.Color

      draw.SubEntityTraits.Color <- (int16 3)

      draw.Geometry.Circle(_cen, _locp, _norm) |> ignore

      draw.SubEntityTraits.Color <- col

 

    // Check the RegenAbort flag...

    // If it's set then we drop out of the function

 

    if not draw.RegenAbort then   

 

      // Generate the spline with low accuracy

      // (fewer control points == quicker)

 

      match _mode with

 

      | RADIUS ->

 

        // Make sure we don't have a p of 0

 

        if _locp = 0.0 then _locp <- 0.001

 

        x.Generate

          (_locp * _ROverP, _locp * _rOverP, _locp,

            _locQ, _locm, _n, _segs)

 

      | MAJOR ->

 

        x.Generate

          (_locR, _locR * _rOverR, _locp, _locQ, _locm, _n, _segs)

 

      | _ ->

 

        x.Generate(_locR, _locr, _locp, _locQ, _locm, _n, _segs)

 

      if not draw.RegenAbort then

        draw.Geometry.Draw(_sp) |> ignore

 

    true

 

  // Set the global defaults based on the last set of successful

  // input values

 

  member x.SetDefaults() =

    _R <- _locR

    _p <- _locp

    _r <- _locr

    _Q <- _locQ

    _m <- _locm

 

  // Generate a more accurate spline

 

  member x.Perfect() =

 

    x.Generate(_R, _r, _p, _Q, _m, _n, _perfSegs)

 

  // Generate a spline

 

  member x.Generate(R, r, p, Q, m, n, num) =

 

    // Generate control points based on the accuracy

 

    let pts = pointsOnGuilloche _cen R r p Q m n num

 

    if _sp <> null then

      _sp.Dispose()

 

    _sp <- new Spline(new Point3dCollection(pts), 1, 0.)

 

  // Accessor for the entity

 

  member x.GetEntity() = _sp

 

  // Let the caller clean-up when cancelling

 

  member x.CleanUp() = _sp.Dispose()

 

end

 

// Our jig-based command

 

[<CommandMethod("GUIJIG")>]

let guillochejig() =

 

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

 

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

 

  if cenRes.Status = PromptStatus.OK then

 

    let cen = cenRes.Value

 

    // Create the spline and run the jig

 

    let jig = new GuillocheJig()

    let res = jig.StartJig(ed, cen)

 

    if res.Status = PromptStatus.OK then

 

      // Perfect the spline created, smoothing it up

 

      jig.SetDefaults()

      jig.Perfect()

 

      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

 

      // Add our spline to the modelspace

 

      let sp = jig.GetEntity()

      let id = ms.AppendEntity(sp)

      tr.AddNewlyCreatedDBObject(sp, true)

 

      tr.Commit()

 

    else

 

      jig.CleanUp()

 

// Set the values back to the program defaults

 

[<CommandMethod("GUIDEFS")>]

let resetGuillocheDefaults() =

  _R <- 50.0

  _r <- -0.2

  _p <- 25.0

  _Q <- 3.0

  _m <- 1.0

  _n <- 6.0

 

[<CommandMethod("GUILLOCHE")>]

let guilloche() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc = Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // First we need some user input

 

  match getGuillocheInput ed with

  | None -> ()

  | Some(R, r, p, Q, m, n, segs, cen) ->

 

    // Next we get a sampling of points along the Guilloche geometry

 

    let pts =

      pointsOnGuilloche

        Point3d.Origin

        R.Value r.Value p.Value Q.Value m.Value n.Value segs.Value

 

    // Use the points as control points on a spline

 

    let sp = new Spline(new Point3dCollection(pts), 1, 0.)

 

    // Move the geometry to the selected point

 

    sp.TransformBy(Matrix3d.Displacement(cen.GetAsVector()))

 

    // Use a transaction to add our spline to the model-space

 

    use tr = db.TransactionManager.StartTransaction()

 

    // Get appropriately-typed BlockTableRecord

 

    let btr =

      tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite)

        :?> BlockTableRecord

 

    // Add our curve to the model-space

 

    let id = btr.AppendEntity(sp)

    tr.AddNewlyCreatedDBObject(sp, true)

 

    // Commit the transaction

 

    tr.Commit()

Here’s an example guilloché pattern being created via GUIJIG. You’re going to have a tough time creating a specific pattern that you’re aiming for, but it’s worth persevering – every so often you strike gold. :-)

Doug also mentioned filling a certain area with a pattern. In this case, I just drew a rectangular polyline using RECTANG and then used TRIM to remove the parts of the spline outside of it. It took a few crossing window selections, but it got there eventually.

Printing your own money with AutoCAD

Here’s a fun one to finish up the week. And no, it isn’t a belated April Fool’s gag. ;-) I should probably say right away that you won’t be printing money after reading this blog post, but you might know more about some of the security measures used by those who do.

A couple of weeks ago, I received an email from Doug Bell at PaperMoneyWorld.net:

I have tried your Spiro for AutoCAD and I enjoy it very much. I would like to challenge you to another function I would like to see that is related to the spirograph. I’d like to see what is called a geometric lathe. I have seen this for a Mac but it doesn't convert to any type of AutoCAD format. Here is a link that will give you more info on it. Thank you.

And with that, Doug introduced me to the fascinating world of guilloché and its use in preventing counterfeiting. (Doug’s interest was due to some posts I’d written on creating Spirograph-like patterns using AutoCAD, which culminated in the Spiro Plugin of the Month and Autodesk Exchange app.)

Before going further with this, I did check in with Doug to make sure I wasn’t becoming an unwitting accomplice in an illegal operation to forge banknotes. Sure enough, Doug confirmed it was related to his hobby (although in this case it seems “passion” is a better description) of collecting military money and creating currency to be used at the festivals he attends with fellow enthusiasts. Doug intends to use a plotted guilloché background to make his own currency more authentic.

That was good enough for me (although it meant I was doing it for fun rather than a suitcase of dodgy dollar bills ;-).

The good news is that the typical guilloché pattern used in security printing is indeed very close to those generated by a Spirograph, both are hypotrochoids. And as the basic mathematical formula – for at least one family of guilloché – was provided in Aegir Hallmundr’s excellent blog post (which Doug had sent through in his email), it was pretty easy to modify the existing F# code to create them.

I did make a few changes to the approach, this time around: rather than creating a jig, I opted for prompting the user via the command-line (and not even updating  the defaults to reflect the previous choices). I also decided to create a Spline rather than a Polyline, as that would reduce the size (on disk) of the resulting geometry and lead to a smoother fit (as the intention is actually to plot these, after all).

Here’s the F# code. It’ll be straightforward to convert to C#, in case (let me know if anyone has an interest in a C# version and I’ll crank one out):

module Guillocher.Commands

 

open Autodesk.AutoCAD.ApplicationServices.Core

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open System

 

// User prompting helper functions

 

let getIntegerWithDefault (ed : Editor) msg min max def =

  let pio = new PromptIntegerOptions(msg)

  pio.LowerLimit <- min

  pio.UpperLimit <- max

  pio.DefaultValue <- def

  pio.UseDefaultValue <- true

 

  let pir = ed.GetInteger(pio)

  if pir.Status = PromptStatus.OK then

    Some(pir.Value)

  else

    None

 

let getDoubleWithDefault (ed : Editor) msg neg zero def =

  let pdo = new PromptDoubleOptions(msg)

  pdo.AllowNegative <- neg

  pdo.AllowZero <- zero

  pdo.DefaultValue <- def

  pdo.UseDefaultValue <- true

 

  let pdr = ed.GetDouble(pdo)

  if pdr.Status = PromptStatus.OK then

    Some(pdr.Value)

  else

    None

 

// Get the various values we need from the user for this command

 

let getGuillocheInput ed =

  let R = getDoubleWithDefault ed "\nR" true false 50.0

  if R = None then

    None

  else

    let r = getDoubleWithDefault ed "\nr" true false -0.2

    if r = None then

      None

    else

      let p = getDoubleWithDefault ed "\np" true false 25.0

      if p = None then

        None

      else

        let Q = getDoubleWithDefault ed "\nQ" true true 3.0

        if Q = None then

          None

        else

          let m = getDoubleWithDefault ed "\nm" true false 1.0

          if m = None then

            None

          else

            let n = getDoubleWithDefault ed "\nn" true false 6.0

            if n = None then

              None

            else

              let segs =

                getIntegerWithDefault

                  ed "\nNumber of control points" 500 32767 3000

              if segs = None then

                None

              else

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

                if ppr.Status = PromptStatus.OK then

                  Some(R, r, p, Q, m, n, segs, ppr.Value)

                else

                  None

 

let pointsOnGuilloche R r p Q m n segs =

  [|

    let period = Math.PI * 2.0;

    for theta in 0.0..period/(float segs)..period do

 

      let rr = R + r

      let rp = r + p

      let rror = rr / r

      let mth = m * theta

      let nth = n * theta

      let k = rror * mth

      let x =

        rr * Math.Cos(mth) + rp * Math.Cos(k) + Q * Math.Cos(nth)

      let y =

        rr * Math.Sin(mth) - rp * Math.Sin(k) + Q * Math.Sin(nth)

 

      yield new Point3d(x, y, 0.0)

  |]

 

[<CommandMethod("GUILLOCHE")>]

let guilloche() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // First we need some user input

 

  match getGuillocheInput ed with

  | None -> ()

  | Some(R, r, p, Q, m, n, segs, cen) ->

 

    // Next we get a sampling of points along the Guilloche geometry

 

    let pts =

      pointsOnGuilloche

        R.Value r.Value p.Value Q.Value m.Value n.Value segs.Value

 

    // Use the points as control points on a spline

 

    let sp = new Spline(new Point3dCollection(pts), 1, 0.0)

 

    // Move the geometry to the selected point

 

    sp.TransformBy(Matrix3d.Displacement(cen.GetAsVector()))

 

    // Use a transaction to add our polyline to the model-space

 

    use tr = db.TransactionManager.StartTransaction()

 

    // Get appropriately-typed BlockTableRecord

 

    let btr =

      tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite)

        :?> BlockTableRecord

 

    // Add our curve to the model-space

 

    let id = btr.AppendEntity(sp)

    tr.AddNewlyCreatedDBObject(sp, true)

 

    // Commit the transaction

 

    tr.Commit()

For further fun, I went ahead and created an equivalent version in DesignScript, for anyone using that (there’s an updated version of the tech preview on Labs, still AutoCAD 2013-based).

import("ProtoGeometry.dll");

import("Math.dll");

 

R = 50;

r = -0.2;

p = 25;

Q = 3;

m = 1;

n = 6;

segs = 3000;

theta = 0..360..360/segs;

 

def guilloche(th)

{

    rr = R + r;

    rp = r + p;

    rror = rr / r;

    mth = m * th;

    nth = n * th;

    k = rror * mth;

    x = rr * Math.Cos(mth) + rp * Math.Cos(k) + Q * Math.Cos(nth);

    y = rr * Math.Sin(mth) - rp * Math.Sin(k) + Q * Math.Sin(nth);

    pt = Point.ByCoordinates(x, y, 0);

    return = pt;

}

 

spline = BSplineCurve.ByPoints(guilloche(theta));

Here it is inside the DesignScript editor:

So that’s about it – in case you’re interested, here’s the resultant DWG with this particular pattern (the one created via the F# code using the default arguments).

Measuring time elapsed during custom AutoCAD command execution using .NET

As a follow-on from the last post, in today’s we’re going to look at a crude approach for collecting execution information about functions of your choosing from a .NET app inside AutoCAD. We’re going to extend the implementation shown last time to record the time taken for the various “instrumented” commands to execute and make it easy to copy and paste this “performance” data into a tool such as Excel. We could also dump out a file directly that can be imported into Excel, but this way is simpler and only slightly more manual.

It’s important to note the quotes in the above paragraph: measuring elapsed time in this way is indeed very crude – it’s only a little bit better than measuring manually with a physical stop-watch (albeit much better than trying to use one of those Casio digital watches from back in the 80s with metal buttons that were so hard to press that they left imprints in your fingertips ;-) – as it’s not at all granular in the data it collects.

Aside from the fact that a modern, multi-tasking OS has a lot of stuff going on that makes elapsed execution time inconsistent, both the OS and the .NET framework understandably do things to make code execute more quickly over time. Which is also a reason we’re implementing a simple way to collect data across multiple runs, as that makes it easier to discard data from early runs that you might want to consider as a warm-up lap for your app.

If you’re really interested in measuring performance, you really ought to invest (whether that means money or time) in using a profiler. Visual Studio 2012 has profiling tools built-in from the Professional version upwards, while with Visual Studio 2010 you apparently need at least the Premium version.

In a future post, it’d be good to take a more in-depth look at profiling AutoCAD apps, but for now we’ll stick with this basic approach. If anyone out there has experience with profiling tools they’d like to share, please do so via a comment. Some tools are no doubt better than others, and it would be good to hear from people on this topic.

With that lengthy preamble out of the way, let’s get onto the code. Here’s an updated version of the C# code shown last time, with some additional work going on in the MeasureTime() method.

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System;

 

namespace ObjectEnumeration

{

  public class Commands

  {

    // An execution "database" mapping between command-name and

    // the list of timings for the various runs

 

    private Dictionary<string, List<TimeSpan>> _execData =

      new Dictionary<string, List<TimeSpan>>();

 

    private void AddExecInfo(string cmd, TimeSpan elapsed)

    {

      // Add the execution info to the existing list for a command

      // or create a new one if none exists

 

      if (_execData.ContainsKey(cmd))

      {

        _execData[cmd].Add(elapsed);

      }

      else

      {

        _execData.Add(cmd, new List<TimeSpan>() { elapsed });

      }

    }

 

    public void MeasureTime(Document doc, Func<int> func)

    {

      // Get the name of the running command(s)

      // (might also have queried the CommandMethod attribute

      // via reflection, but that would be a lot more work)

 

      var cmd = (string)Application.GetSystemVariable("CMDNAMES");

 

      // Start a Stopwatch to time the execution

 

      var sw = new Stopwatch();

      sw.Start();

 

      // Run the function, getting back the count of the results

 

      var cnt = func();

 

      // Stop the Stopwatch and print the results to the command-line

 

      sw.Stop();

      doc.Editor.WriteMessage(

        "\n{0}: found {1} lines in {2}.", cmd, cnt, sw.Elapsed

      );

 

      // Store the execution information for later use

 

      AddExecInfo(cmd, sw.Elapsed);

    }

 

    [CommandMethod("DD")]

    public void DumpExecutions()

    {

      // Loop through the execution database, dumping the results

      // to the command-line

 

      var ed =

        Application.DocumentManager.MdiActiveDocument.Editor;

 

      foreach (var kv in _execData)

      {

        ed.WriteMessage("\n{0}", kv.Key);

        foreach (var ts in kv.Value)

        {

          ed.WriteMessage(",{0}", ts.TotalMilliseconds);

        }

      }

    }

 

    [CommandMethod("LL1")]

    public void ListLines1()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      MeasureTime(

        doc,

        () =>

        {

          var ids = GetAllLines(doc.Database);

          return ids.Count<Line>();

        }

      );

    }

 

    [CommandMethod("LL2")]

    public void ListLines2()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      MeasureTime(

        doc,

        () =>

        {

          var ids =

            ObjectsOfType1(

              doc.Database, RXObject.GetClass(typeof(Line))

            );

          return ids.Count<ObjectId>();

        }

      );

    }

 

    [CommandMethod("LL3")]

    public void ListLines3()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      MeasureTime(

        doc,

        () =>

        {

          var ids =

            ObjectsOfType2(

              doc.Database, RXObject.GetClass(typeof(Line))

            );

          return ids.Count<ObjectId>();

        }

      );

    }

 

    public static IEnumerable<Line> GetAllLines(Database db)

    {

      using (

        var docLock =

         Application.DocumentManager.MdiActiveDocument.LockDocument()

        )

      {

        using (var tr = db.TransactionManager.StartTransaction())

        {

          var bt =

            tr.GetObject(db.BlockTableId, OpenMode.ForRead)

            as BlockTable;

          var btr =

            tr.GetObject(

              bt[BlockTableRecord.ModelSpace],

              OpenMode.ForRead

            ) as BlockTableRecord;

 

          foreach (var obj in btr)

          {

            var line =

              tr.GetObject(obj, OpenMode.ForRead) as Line;

 

            if (line != null)

            {

              yield return line;

            }

          }

        }

      }

    }

 

    public static IEnumerable<ObjectId> ObjectsOfType1(

      Database db, RXClass cls

    )

    {

      var tr = db.TransactionManager.StartOpenCloseTransaction();

      using (tr)

      {

        var btr =

          (BlockTableRecord)tr.GetObject(

            SymbolUtilityServices.GetBlockModelSpaceId(db),

            OpenMode.ForRead

          );

        foreach (ObjectId id in btr)

        {

          if (id.ObjectClass.IsDerivedFrom(cls))

          {

            yield return id;

          }

        }

        tr.Commit();

      }

    }

 

    public static IEnumerable<ObjectId> ObjectsOfType2(

      Database db, RXClass cls

    )

    {

      var tr = db.TransactionManager.StartOpenCloseTransaction();

      using (tr)

      {

        var btr =

          (BlockTableRecord)tr.GetObject(

            SymbolUtilityServices.GetBlockModelSpaceId(db),

            OpenMode.ForRead

          );

 

        var lineIds =

          from ObjectId id in btr

          where id.ObjectClass.IsDerivedFrom(cls)

          select id;

 

        tr.Commit();

 

        return lineIds;

      }

    }

  }

}

We’ve simply added a dictionary that maps between command-names and a list of TimeSpan objects (one for each execution of that command, stored chronologically). After executing LL1, LL2 and LL3 multiple times – perhaps even using a script to do so – you can then call DD to dump the results to the command-line:

As the data dumped to the command-line is comma-delimited, it’s easy to copy & paste this into Excel and then use its Text Import Wizard to more effectively populate your performance spreadsheet.

Then, of course, the AutoSum –> Average function makes it easy to average out a subset of the runs (in order to exclude early ones, should you wish to do so).

All very basic, yes, but it can help give you a rough idea of relative performance of different command implementations (and sometimes that’s enough).

Just to finish up the story we started last time, the major problem Bruno ended up finding in his code was that it was relying on exceptions to determine when certain error conditions were in place (related to the existence of XData in his drawing). Once he modified the code to check for these conditions explicitly – rather than relying on catching exceptions – it ran within his performance parameters (in his own words, it’s now “lightning fast!”).