Through the Interface

AU 2010 Classes

The class catalogs for AU 2010 – for both the physical and virtual classes – have now been posted to the AU website:

I have a few AU classes scheduled – thanks to any of you who took the time to vote for them.

My first class is virtual…

Getting to Know the AutoCAD® Plugins of the Month (CP212-1V)

Tuesday November 30th, 6:00-7:00 am PST
Tuesday November 30th, 11:00 am-12:00 pm PST

The Autodesk Developer Network (ADN) team has been publishing "Plug-ins of the Month" on Autodesk Labs for over a year. Each of these plug-ins extends an Autodesk® product in a useful or interesting way, and is provided with full source code! Attend this class for an introduction to the various AutoCAD plug-ins that have been published (with a brief mention of those published for other products). We will take a detailed look at the source code of a few of the most popular plug-ins, to help explain their architecture and implementation.

All Levels. AutoCAD users with an interest in learning more about programming, and how they might use Microsoft .NET to tailor AutoCAD to their specific business needs.

I’ll be recording this on the Sunday afternoon, apparently, which means arriving in Las Vegas on the Saturday. The first broadcast session is at 6am on the morning after the ADN party at AU, which is going to be a little hard-going. Ah well. I’m also planning on attending the DevLab session that we’re holding on that day, so I’ll have to either duck out or find a quiet corner to go online for the second session.

The other two are physical sessions…

Integrate F# into Your C# or VB.NET Application for an 8x Performance Boost (CP322-2)

Wednesday December 1st, 11:00 am-12:00 pm

Learn how you can use F#, the new programming language from Microsoft®, to achieve performance gains in applications managing multiple, asynchronous tasks. We will examine a sample application to understand how it was designed to download and process multiple point cloud files from the Microsoft's Photosynth® web service and how the use of F# boosted performance by eight times.

While examining the "Point Clouds on a Shoestring" application, we will discuss the benefits of using the Windows® Presentation Foundation (WPF) when designing a modern GUI. We will discuss additional techniques, such as using an advanced browser component to monitor HTTP traffic during a browsing session and isolating a modeless UI in a separate executable to increase portability across 32- and 64-bit platforms.

Intermediate. VB.NET/C# developers interested in learning about the benefits of F# and non-programmer attendees of the "Point Cloud on a Shoestring" session interested in more in-depth technical information about working with point clouds

Point Clouds on a Shoestring (AC427-4)

Thursday December 2nd, 1:30-2:30 pm

Have you always wanted to play around with point clouds but your boss will not buy you an expensive laser scanner? Come to this entertaining class to see how it is possible to use "free" technology, such as Microsoft® Photosynth®, to generate 3D point
clouds from 2D photographs. See a live demonstration of a real-world object being “captured” using nothing but a digital SLR and then brought into AutoCAD® 2011 as a 3D point cloud.

We will also spend some time looking at AutoCAD 2011 point cloud capabilities and the state of “reality capture” technology in the industry. A separate session in the Customization and Programming track, "Integrate F# into Your C# or VB.NET Application for an 8x Performance Boost," will take a look more closely examine the technology shown in this session.

All Levels. Anyone interested in learning about point clouds and how they can be generated and used with tools such as Microsoft Photosynth and AutoCAD 2011

In a sense it would have made more sense to hold the first “under the hood” session after the second, but in reality it probably doesn’t matter: I suspect different people will attend each session, in any case.

To streamline the live demo in the second of these sessions, I’ve just bought an Eye-Fi SD card for my digital SLR, which should allow me to stream pictures directly to my PC as they’re being taken. At least that’s my hope – I’m very much looking forward to trying it out.

Hopefully see you in Vegas! :-)

It was 15 years ago today

I started working at Autodesk 15 years ago on August 29^th, 1995.

Part of me wanted to start this post by saying “it seems like only yesterday that I started working for Autodesk…”, but the truth is, it doesn’t. It feels longer, but not for bad reasons: mainly because so much has happened in the last 15 years, whether from a technological, professional or personal perspective.

[I wish it were 20 years, though, just so it’d make for a better Beatles lyrics quote. But who knows if I’ll still be here in 5 years? Better to use it now, rather than risk never getting there. ;-)]

For a little anniversary fun, I scanned in my various business cards, over the years (I may have missed one or two – ADN has lived in a number of different organisations within Autodesk during this period so I had a few reprints), but there’s certainly at least one below from each of the positions I’ve held.

If you’ve had the patience to look at a few of these, you’ll notice I’ve had a number of different roles (and in different countries) within the ADN team, a few of which were before it was even known as ADN. And it’s been great, more or less all the way through.

In fact, a friend of mine asked me a few days ago whether 15 years wasn’t too long – from a career perspective – to be in a single organisation: he, himself, has had quite a different career, so it was an understandable question. All I could tell him is that I enjoy my work more today than I ever have before.

On a daily basis I get to work with bright, motivated, interesting people (I’m thinking particularly of the ADN & DevTech teams, but also many of the other people I interact with from both inside and outside of Autodesk). I’m involved in more interesting activities than ever, many of which I even get to talk about publicly. And this blog has just been a fantastic experience: not only because I love to communicate technical ideas (and yes, I do enjoy having my own private soapbox ;-) but because it has ultimately enabled a lot of the other fun stuff I get involved in within the company.

So thanks to all of you for helping me find the motivation to still be here! :-)

Jigging an upright, square, AutoCAD raster image using .NET

Following on from these two posts, we’re now going to implement a jig to create our QR Code raster images inside AutoCAD.

Today’s approach isn’t radically different from the previous one prompting selection of corners, but we do get to see the actual (square) boundary of the raster object as it gets defined. It would have been even better if the raster contents were displayed during the jig, but from what I can tell this has been disabled deliberately, no doubt for performance reasons (you see the same effect – only having the boundary visible – when you move or edit a raster via its grips, for instance). I had hoped that, just like for BlockReferences and Solid3d objects, adding the raster image to the drawing before jigging it – and so passing the RasterImage to the jig, rather than the ObjectId of the RasterImageDef – would cause the contents to be displayed in full, but unfortunately it didn’t change anything. So I backed out those changes, and have continued with the typical, more transient approach to jigging.

Here’s the updated C# code, with new/updated lines in red (here’s the source file for download):

    1 using Autodesk.AutoCAD.Runtime;

    2 using Autodesk.AutoCAD.ApplicationServices;

    3 using Autodesk.AutoCAD.DatabaseServices;

    4 using Autodesk.AutoCAD.EditorInput;

    5 using Autodesk.AutoCAD.Geometry;

    6 using System;

    7 

    8 namespace QRCodeApplication

    9 {

   10   public class Commands

   11   {

   12     class SquareRasterJig : EntityJig

   13     {

   14       Matrix3d _ucs;

   15       Point3d _start = Point3d.Origin;

   16       Point3d _end = Point3d.Origin;

   17 

   18       public SquareRasterJig(

   19         ObjectId defId,

   20         Matrix3d ucs,

   21         Point3d start

   22       ) : base(new RasterImage())

   23       {

   24         _start = start;

   25         _ucs = ucs;

   26 

   27         RasterImage ri = (RasterImage)Entity;

   28         ri.ImageDefId = defId;

   29 

   30         // Create a near zero size default image,

   31         // to avoid the boundary flicker

   32 

   33         double size = Tolerance.Global.EqualPoint;

   34         ri.Orientation =

   35           new CoordinateSystem3d(

   36             _start,

   37             new Vector3d(size, 0, 0),

   38             new Vector3d(0, size, 0)

   39           );

   40         ri.ShowImage = true;

   41       }

   42 

   43       protected override SamplerStatus Sampler(

   44         JigPrompts prompts

   45       )

   46       {

   47         JigPromptPointOptions opts =

   48           new JigPromptPointOptions();

   49         opts.UserInputControls =

   50           (UserInputControls.Accept3dCoordinates |

   51           UserInputControls.NoNegativeResponseAccepted);

   52         opts.Message = "\nSecond corner of QR Code: ";

   53 

   54         // Get the point itself

   55 

   56         PromptPointResult res = prompts.AcquirePoint(opts);

   57 

   58         if (res.Status == PromptStatus.OK)

   59         {

   60           // Convert the supplied point into UCS

   61 

   62           Point3d tmp =

   63             res.Value.TransformBy(_ucs.Inverse());

   64 

   65           // Check if changed (reduces flicker)

   66 

   67           if (_end == tmp)

   68           {

   69             return SamplerStatus.NoChange;

   70           }

   71           else

   72           {

   73             _end = tmp;

   74             return SamplerStatus.OK;

   75           }

   76         }

   77         return SamplerStatus.Cancel;

   78       }

   79 

   80       protected override bool Update()

   81       {

   82         RasterImage ri = (RasterImage)Entity;

   83 

   84         // Get offset between the two corners

   85 

   86         Vector3d diff = _end - _start;

   87 

   88         // Get the smallest of the X and Y

   89         // (could also be the largest - this is a choice)

   90 

   91         double size =

   92           Math.Min(Math.Abs(diff.X), Math.Abs(diff.Y));

   93 

   94         // If we're at zero size, don't update

   95 

   96         if (size < Tolerance.Global.EqualPoint)

   97           return false;

   98 

   99         // Determing the image's orientation...

  100 

  101         // The original will depend on the order of the corners

  102         // It will be offset to the left and/or down depending

  103         // on the values of the vector between the two points

  104 

  105         Point3d orig;

  106 

  107         // The axes stay the same, as we will always keep the

  108         // image oriented the same way relative to the UCS

  109 

  110         Vector3d xAxis = new Vector3d(size, 0, 0);

  111         Vector3d yAxis = new Vector3d(0, size, 0);

  112 

  113         if (diff.X > 0 && diff.Y > 0) // Dragging top-right

  114           orig = _start;

  115         else if (diff.X < 0 && diff.Y > 0) // Top-left

  116           orig = _start + new Vector3d(-size, 0, 0);

  117         else if (diff.X > 0 && diff.Y < 0) // Bottom-right

  118           orig = _start + new Vector3d(0, -size, 0);

  119         else // if (diff.X < 0 && diff.Y < 0) // Bottom-left

  120           orig = _start - new Vector3d(size, size, 0);

  121 

  122         // Set the image's orientation in WCS

  123 

  124         ri.Orientation =

  125           new CoordinateSystem3d(

  126             orig.TransformBy(_ucs),

  127             xAxis.TransformBy(_ucs),

  128             yAxis.TransformBy(_ucs)

  129           );

  130 

  131         return true;

  132       }

  133 

  134       public Entity GetEntity()

  135       {

  136         return Entity;

  137       }

  138     }

  139 

  140     [CommandMethod("QR")]

  141     static public void QRCode()

  142     {

  143       // Base record name and URL constants

  144 

  145       const string recBase = "ADNP_QR";

  146       const string rootUrl =

  147         "http://chart.apis.google.com/chart?cht=qr&chs=500x500&chl=";

  148 

  149       Document doc =

  150         Application.DocumentManager.MdiActiveDocument;

  151       Database db = doc.Database;

  152       Editor ed = doc.Editor;

  153 

  154       PromptResult pr =

  155         ed.GetString("\nEnter email address to encode: ");

  156       if (pr.Status != PromptStatus.OK)

  157         return;

  158 

  159       // Encode the colon and the @ symbol for the URL

  160 

  161       string message =

  162         "mailto%3A" + pr.StringResult.Replace("@", "%40");

  163 

  164       Transaction tr =

  165         doc.TransactionManager.StartTransaction();

  166       using (tr)

  167       {

  168         ObjectId dictId =

  169           RasterImageDef.GetImageDictionary(db);

  170 

  171         if (dictId.IsNull)

  172         {

  173           // Image dictionary doesn't exist, create new

  174 

  175           dictId =

  176             RasterImageDef.CreateImageDictionary(db);

  177         }

  178 

  179         // Open the image dictionary

  180 

  181         DBDictionary dict =

  182           (DBDictionary)tr.GetObject(

  183             dictId,

  184             OpenMode.ForRead

  185           );

  186 

  187         // Get a unique record name for our raster image

  188         // definition

  189 

  190         int i = 0;

  191         string recName = recBase + i.ToString();

  192 

  193         while (dict.Contains(recName))

  194         {

  195           i++;

  196           recName = recBase + i.ToString();

  197         }

  198 

  199         RasterImageDef rid = new RasterImageDef();

  200 

  201         // Set its source image

  202 

  203         rid.SourceFileName = rootUrl + message;

  204 

  205         // Load it

  206 

  207         rid.Load();

  208         dict.UpgradeOpen();

  209 

  210         ObjectId defId = dict.SetAt(recName, rid);

  211 

  212         // Let the transaction know

  213 

  214         tr.AddNewlyCreatedDBObject(rid, true);

  215 

  216         PromptPointResult ppr =

  217           ed.GetPoint("\nFirst corner of QR Code: ");

  218         if (ppr.Status != PromptStatus.OK)

  219           return;

  220 

  221         // Call our jig to define the raster

  222 

  223         SquareRasterJig jig =

  224           new SquareRasterJig(

  225             defId,

  226             ed.CurrentUserCoordinateSystem,

  227             ppr.Value

  228           );

  229         PromptResult prj = ed.Drag(jig);

  230 

  231         if (prj.Status != PromptStatus.OK)

  232         {

  233           rid.Erase();

  234           return;

  235         }

  236 

  237         // Get our entity and add it to the modelspace

  238 

  239         RasterImage ri = (RasterImage)jig.GetEntity();

  240 

  241         BlockTable bt =

  242           (BlockTable)tr.GetObject(

  243             db.BlockTableId,

  244             OpenMode.ForRead

  245           );

  246 

  247         BlockTableRecord btr =

  248           (BlockTableRecord)tr.GetObject(

  249             bt[BlockTableRecord.ModelSpace],

  250             OpenMode.ForWrite

  251           );

  252 

  253         btr.AppendEntity(ri);

  254         tr.AddNewlyCreatedDBObject(ri, true);

  255 

  256         // Create a reactor between the RasterImage and the

  257         // RasterImageDef to avoid the "unreferenced"

  258         // warning in the XRef palette

  259 

  260         RasterImage.EnableReactors(true);

  261         ri.AssociateRasterDef(rid);

  262 

  263         // Let's add our message string as XData,

  264         // in case we need it later

  265 

  266         AddRegAppTableRecord("ADNP_QR");

  267         ResultBuffer rb =

  268           new ResultBuffer(

  269             new TypedValue(1001, "ADNP_QR"),

  270             new TypedValue(1000, message)

  271           );

  272         ri.XData = rb;

  273         rb.Dispose();

  274 

  275         tr.Commit();

  276       }

  277     }

  278 

  279     static void AddRegAppTableRecord(string regAppName)

  280     {

  281       Document doc =

  282         Application.DocumentManager.MdiActiveDocument;

  283       Editor ed = doc.Editor;

  284       Database db = doc.Database;

  285 

  286       Transaction tr =

  287         doc.TransactionManager.StartTransaction();

  288       using (tr)

  289       {

  290         RegAppTable rat =

  291           (RegAppTable)tr.GetObject(

  292             db.RegAppTableId,

  293             OpenMode.ForRead,

  294             false

  295           );

  296         if (!rat.Has(regAppName))

  297         {

  298           rat.UpgradeOpen();

  299           RegAppTableRecord ratr =

  300             new RegAppTableRecord();

  301           ratr.Name = regAppName;

  302           rat.Add(ratr);

  303           tr.AddNewlyCreatedDBObject(ratr, true);

  304         }

  305         tr.Commit();

  306       }

  307     }

  308   }

  309 }

The changes themselves should be reasonably clear: the code defining the size of the boundary has been moved to the jig, and we’re now using the jig to manage the user input.

Here's what happens when we use our updated QR command to jig the position and size of a QR Code:

 

I haven’t implemented rotation, as it’s not clear to me that it needs to be an integrated part of the QR command. If it’s only needed rarely – my current expectation – it’s probably better to leave it to an existing command such as PROPERTIES or ROTATE.

The next stage in this application’s development is to take a look at some kind of UI for defining different sets of content, as well as the ability to edit the contents of an existing QR Code.

RockScroll: my new favourite Visual Studio Add-In

Thanks to Kristine Middlemiss, from our DevTech Media & Entertainment team, for bringing this very cool application to my attention.

There a few Visual Studio Add-Ins that I can no longer do without. I use CopySourceAsHtml for every blog post of mine that includes source code, and I’m now just beginning to form a similar dependency on RockScroll. This Add-In integrates with Visual Studio (in my case 2008, as I’m typically slow to install the latest & greatest VS release) to display a thumbnail view of your current source file in a fattened, still perfectly functional scrollbar:

This tool is very useful, indeed, when navigating very large source files.

Attaching an “upright” raster image at a user-specified location in an AutoCAD drawing using .NET

As promised, the code in this post extends that from the last post to add some user selection to the process of defining and placing a QR Code in an AutoCAD drawing.

This version of the code also makes sure the raster is positioned in an “upright” orientation, irrespective of the order in which the corners are selected. Many images need to be positioned in such a way (although QR Codes are presumably more tolerant due to the positioning squares in three of the corners), so I expect this technique will be of interest to various people who need to place images at user-specified locations. QR Codes are also square, so we’re choosing the smallest of the axes to define size (we could very easily also take the largest). This approach will become even more interesting when we migrate it to a jig, so we actually see a square area during the selection process.

One final change: I’ve used code from this previous post to add the message string as XData to the raster image. This will allow us to provide some kind of interface for updating the string, in the future (should we need to). Although we could probably also divine this from the image's URL, as an alternative approach.

Here’s the updated C# code, with modified or new lines in red (here’s the source file for download):

    1 using Autodesk.AutoCAD.Runtime;

    2 using Autodesk.AutoCAD.ApplicationServices;

    3 using Autodesk.AutoCAD.DatabaseServices;

    4 using Autodesk.AutoCAD.EditorInput;

    5 using Autodesk.AutoCAD.Geometry;

    6 using System;

    7 

    8 namespace QRCodeApplication

    9 {

   10   public class Commands

   11   {

   12     [CommandMethod("QR")]

   13     static public void QRCode()

   14     {

   15       // Base record name and URL constants

   16 

   17       const string recBase = "ADNP_QR";

   18       const string rootUrl =

   19         "http://chart.apis.google.com/chart?cht=qr&chs=500x500&chl=";

   20 

   21       Document doc =

   22         Application.DocumentManager.MdiActiveDocument;

   23       Database db = doc.Database;

   24       Editor ed = doc.Editor;

   25 

   26       PromptResult pr =

   27         ed.GetString("\nEnter email address to encode: ");

   28       if (pr.Status != PromptStatus.OK)

   29         return;

   30 

   31       // Encode the colon and the @ symbol for the URL

   32 

   33       string message =

   34         "mailto%3A" + pr.StringResult.Replace("@", "%40");

   35 

   36       Transaction tr =

   37         doc.TransactionManager.StartTransaction();

   38       using (tr)

   39       {

   40         ObjectId dictId =

   41           RasterImageDef.GetImageDictionary(db);

   42 

   43         if (dictId.IsNull)

   44         {

   45           // Image dictionary doesn't exist, create new

   46 

   47           dictId =

   48             RasterImageDef.CreateImageDictionary(db);

   49         }

   50 

   51         // Open the image dictionary

   52 

   53         DBDictionary dict =

   54           (DBDictionary)tr.GetObject(

   55             dictId,

   56             OpenMode.ForRead

   57           );

   58 

   59         // Get a unique record name for our raster image

   60         // definition

   61 

   62         int i = 0;

   63         string recName = recBase + i.ToString();

   64 

   65         while (dict.Contains(recName))

   66         {

   67           i++;

   68           recName = recBase + i.ToString();

   69         }

   70 

   71         RasterImageDef rid = new RasterImageDef();

   72 

   73         // Set its source image

   74 

   75         rid.SourceFileName = rootUrl + message;

   76 

   77         // Load it

   78 

   79         rid.Load();

   80         dict.UpgradeOpen();

   81 

   82         ObjectId defId = dict.SetAt(recName, rid);

   83 

   84         // Let the transaction know

   85 

   86         tr.AddNewlyCreatedDBObject(rid, true);

   87 

   88         PromptPointResult ppr =

   89           ed.GetPoint("\nFirst corner of QR Code: ");

   90         if (ppr.Status != PromptStatus.OK)

   91           return;

   92 

   93         Point3d start = ppr.Value;

   94 

   95         ppr =

   96           ed.GetCorner("\nSecond corner of QR Code: ", start);

   97         if (ppr.Status != PromptStatus.OK)

   98           return;

   99 

  100         // Get offset between the two corners

  101 

  102         Vector3d diff = ppr.Value - start;

  103 

  104         // Get the smallest of the X and Y

  105         // (could also be the largest - this is a choice)

  106 

  107         double size =

  108           Math.Min(Math.Abs(diff.X), Math.Abs(diff.Y));

  109 

  110         // If we're at zero size, don't update

  111 

  112         if (size < Tolerance.Global.EqualPoint)

  113           return;

  114 

  115         // Determing the image's orientation...

  116 

  117         // The original will depend on the order of the corners

  118         // It will be offset to the left and/or down depending

  119         // on the values of the vector between the two points

  120 

  121         Point3d orig;

  122 

  123         // The axes stay the same, as we will always keep the

  124         // image oriented the same way relative to the UCS

  125 

  126         Vector3d xAxis = new Vector3d(size, 0, 0);

  127         Vector3d yAxis = new Vector3d(0, size, 0);

  128 

  129         if (diff.X > 0 && diff.Y > 0) // Dragging top-right

  130           orig = start;

  131         else if (diff.X < 0 && diff.Y > 0) // Top-left

  132           orig = start + new Vector3d(-size, 0, 0);

  133         else if (diff.X > 0 && diff.Y < 0) // Bottom-right

  134           orig = start + new Vector3d(0, -size, 0);

  135         else // if (diff.X < 0 && diff.Y < 0) // Bottom-left

  136           orig = start - new Vector3d(size, size, 0);

  137 

  138         // Create the raster image that references the

  139         // definition

  140 

  141         RasterImage ri = new RasterImage();

  142         ri.ImageDefId = defId;

  143         ri.ShowImage = true;

  144 

  145         // Set the image's orientation in WCS

  146 

  147         Matrix3d ucs = ed.CurrentUserCoordinateSystem;

  148 

  149         ri.Orientation =

  150           new CoordinateSystem3d(

  151             orig.TransformBy(ucs),

  152             xAxis.TransformBy(ucs),

  153             yAxis.TransformBy(ucs)

  154           );

  155 

  156         BlockTable bt =

  157           (BlockTable)tr.GetObject(

  158             db.BlockTableId,

  159             OpenMode.ForRead

  160           );

  161 

  162         BlockTableRecord btr =

  163           (BlockTableRecord)tr.GetObject(

  164             bt[BlockTableRecord.ModelSpace],

  165             OpenMode.ForWrite

  166           );

  167 

  168         btr.AppendEntity(ri);

  169         tr.AddNewlyCreatedDBObject(ri, true);

  170 

  171         // Create a reactor between the RasterImage and the

  172         // RasterImageDef to avoid the "unreferenced"

  173         // warning in the XRef palette

  174 

  175         RasterImage.EnableReactors(true);

  176         ri.AssociateRasterDef(rid);

  177 

  178         // Let's add our message string as XData,

  179         // in case we need it later

  180 

  181         AddRegAppTableRecord("ADNP_QR");

  182         ResultBuffer rb =

  183           new ResultBuffer(

  184             new TypedValue(1001, "ADNP_QR"),

  185             new TypedValue(1000, message)

  186           );

  187         ri.XData = rb;

  188         rb.Dispose();

  189 

  190         tr.Commit();

  191       }

  192     }

  193 

  194     static void AddRegAppTableRecord(string regAppName)

  195     {

  196       Document doc =

  197         Application.DocumentManager.MdiActiveDocument;

  198       Editor ed = doc.Editor;

  199       Database db = doc.Database;

  200 

  201       Transaction tr =

  202         doc.TransactionManager.StartTransaction();

  203       using (tr)

  204       {

  205         RegAppTable rat =

  206           (RegAppTable)tr.GetObject(

  207             db.RegAppTableId,

  208             OpenMode.ForRead,

  209             false

  210           );

  211         if (!rat.Has(regAppName))

  212         {

  213           rat.UpgradeOpen();

  214           RegAppTableRecord ratr =

  215             new RegAppTableRecord();

  216           ratr.Name = regAppName;

  217           rat.Add(ratr);

  218           tr.AddNewlyCreatedDBObject(ratr, true);

  219         }

  220         tr.Commit();

  221       }

  222     }

  223   }

  224 }

Let’s take a look at the individual changes:

• Line 6
  • Add the System namespace for the various Math functions we’re now using
• Lines 24-34
  • Query the user for the email address to encode
• Lines 88-136
  • Query for the location of the image, manipulate the position of the image so that it's "upright"
• Lines 145-154
  • Transform the orientation relative to the current UCS
• Lines 178-188 & 194-222
  • Add the message string as XData, so we can come back and get it/update it in the future

We can see that as we run the QR command we can enter an email address to encode (we’ll extend this UI to cover other types of relevant information, at some point) as well as the location of the QR Code. Irrespective of the order of corner selection, the raster is always square and upright:

Attaching a (QR Code) raster image using AutoCAD .NET

This week I decided to get started on the QR Code Plugin of the Month I mentioned in this previous post, and show a few interesting techniques along the way. The introductory post mentioned a few different approaches for creating/embedding the codes in a drawing. For now – as it’s by far the simplest – I’ve chosen to insert the code as a raster image. In this post we’ll show how to define and insert a raster image of a QR Code into the drawing – for now one with a hardcoded message string, placed at the origin – and we’ve evolve the code over a couple of different posts to provide more control over the contents and placement, first by using selection functions and then by implementing a jig.

At some point I’ll have to implement some kind of user interface for defining QR Codes: I’ll probably take inspiration for that from the ZXing QR Code Generator.

Here’s the C# code for this initial implementation, much of which was based on this DevNote on the ADN site:

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

 

namespace QRCodeApplication

{

  public class Commands

  {

    [CommandMethod("QR")]

    static public void QRCode()

    {

      // Base record name and URL constants

 

      const string recBase = "ADNP_QR";

      const string rootUrl =

        "http://chart.apis.google.com/chart?cht=qr&chs=500x500&chl=";

 

      // Hardcode our message, for now

 

      string message = "mailto%3Akean.walmsley%40autodesk.com";

 

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

 

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        ObjectId dictId =

          RasterImageDef.GetImageDictionary(db);

 

        if (dictId.IsNull)

        {

          // Image dictionary doesn't exist, create new

 

          dictId =

            RasterImageDef.CreateImageDictionary(db);

        }

 

        // Open the image dictionary

 

        DBDictionary dict =

          (DBDictionary)tr.GetObject(

            dictId,

            OpenMode.ForRead

          );

 

        // Get a unique record name for our raster image

        // definition

 

        int i = 0;

        string recName = recBase + i.ToString();

 

        while (dict.Contains(recName))

        {

          i++;

          recName = recBase + i.ToString();

        }

 

        RasterImageDef rid = new RasterImageDef();

 

        // Set its source image

 

        rid.SourceFileName = rootUrl + message;

 

        // Load it

 

        rid.Load();

        dict.UpgradeOpen();

 

        ObjectId defId = dict.SetAt(recName, rid);

 

        // Let the transaction know

 

        tr.AddNewlyCreatedDBObject(rid, true);

 

        // Create the raster image that references the

        // definition

 

        RasterImage ri = new RasterImage();

        ri.ImageDefId = defId;

        ri.ShowImage = true;

 

        // Just place the image at the origin in a unit square

 

        ri.Orientation =

          new CoordinateSystem3d(

            Point3d.Origin,

            new Vector3d(1, 0, 0),

            new Vector3d(0, 1, 0)

          );

 

        BlockTable bt =

          (BlockTable)tr.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

 

        BlockTableRecord btr =

          (BlockTableRecord)tr.GetObject(

            bt[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite

          );

 

        btr.AppendEntity(ri);

        tr.AddNewlyCreatedDBObject(ri, true);

 

        // Create a reactor between the RasterImage and the

        // RasterImageDef to avoid the "unreferenced"

        // warning in the XRef palette

 

        RasterImage.EnableReactors(true);

        ri.AssociateRasterDef(rid);

 

        tr.Commit();

      }

    }

  }

}

Here are the results of running the QR command:

 

In the next post we’ll provide a simple, command-line based UI for the message to be encoded (probably still an email address, for now) as well as letting the user select the location of the attached image. This is actually more interesting than it sounds, as we’ll implement some logic to keep the image in this orientation irrespective of the order in which the corners are selected. But more on that in due course.

Capturing a point cloud of a monument using Photosynth

A couple of weekends ago, shortly after returning from our trip to the States, I walked down to the area of Lake Neuchâtel that’s nearest our house, called La Tène (which is now also the name of our local commune (or municipality), which was recently created as a result of fusing Marin-Epagnier with Thielle-Wavre… thankfully they didn’t call it Marin-Epagnier-Thielle-Wavre ;-). On the way I stopped off to take a few photos of a local monument.

La Tène culture is apparently quite famous in archeological circles, and the monument itself is pretty cool. It’s a replica of an Iron Age sword found in the area, but seven times the original size and mounted on a monolith. Here’s the monument’s plaque, for all you French-speakers:

Anyway, I ended up taking more than a few (in the end I took 497!) 12.1 megapixel images of this monument, and uploaded them to Photosynth. I wasn’t expecting much: Photosynth warned me I was uploading a lot of pictures and that the synth process could very well fail. I was also aware that Photosynth’s synther only uses 2 megapixel (or lower) versions of the images, but I decided to go ahead and upload the full-sized images, anyway.

Here are the results:

Here is the Photosynth’s point cloud imported into AutoCAD 2011, which I brought in using the application in this previous post (which I expect to become a Plugin of the Month in October, all being well):

I’ve been trying to upload this same data-set to Photofly via Photo Scene Editor, but have been having trouble getting the full scene created. If I manage to complete that I’ll present the results from Photofly in a separate post. And then hopefully the results of using the laser scanner, too, although only if the sun comes back out (it really feels as though summer is already over here in Switzerland :-( ).

New version of the AutoCAD .NET Wizard posted

A new version of the AutoCAD .NET Wizard – compatible with AutoCAD 2011 and with Visual Studio 2010 – has been posted to the AutoCAD Developer Center (and you can also get it from this direct link (8.74 MB)).

The download size has jumped from a little under a megabyte its current size: this is due to a very helpful screencast recorded by Stephen Preston and included in the Wizard’s distribution.

If you’ve been using prior versions of this Wizard – or are just interested in its capabilities – be sure to check it out!

Bringing 3ds Max point clouds into AutoCAD 2011

Some of you may have seen the point cloud tool for 3ds Max and 3ds Max Design posted on Autodesk Labs. This plugin currently works with points defined in an ASCII format, although I expect in time it will support similar formats to those supported by AutoCAD.

In case you’re interested in bringing point cloud files that intended for – or generated/edited by – this tool into AutoCAD, I thought I’d share a quick tip. You can use the TXT2LAS tool – which I’ve used extensively in my efforts to bring point clouds into AutoCAD from Photosynth and Photofly – to convert the PTS file into a LAS, and then index/attach the file there.

PTS files are simply space-delimited text files, with the first line containing the number of points. The txt2las tool doesn’t need this number, so you can ignore the warning it’ll generate (or delete the first line from the file – your choice).

Each subsequent line is comprised of the XYZ values of the point, followed by an unknown (to me, anyway) decimal (which was the same for each point in the file I tested with, so I’ve just ignored it) and then finally the RGB values of that point:

755047

55.74190000 77.90000000 4.15650000 0.1 246 246 246

55.74190000 77.90000000 4.15610000 0.1 246 246 246

55.74190000 77.90000000 4.15570000 0.1 246 246 246

55.74190000 77.90000000 4.15580000 0.1 245 245 245

55.74190000 77.90000000 4.15580000 0.1 246 246 246

55.74190000 77.90000000 4.15590000 0.1 246 246 246

55.74190000 77.90000000 4.15550000 0.1 245 245 245

55.74190000 77.89990000 4.15580000 0.1 245 245 245

55.74190000 77.89990000 4.15590000 0.1 245 245 245

...

With all this in mind, here’s a working usage example for creating a LAS from a PTS using the txt2las utility:

txt2las -parse xyzsRGB -i test.pts -o test.las

Trying this with the Lobby_Scan_Ascii.pts sample file linked to from the Labs page…

… we end up with a LAS file that can be indexed in AutoCAD using POINTCLOUDINDEX and attached using POINTCLOUDATTACH:

Importing the output from Photofly via the Photo Scene Editor into AutoCAD

In this previous post I showed some code which uploads photos to Photofly and pulls down and imports the resultant point cloud into AutoCAD 2011. The application relies on a special executable from the Photofly team which was built from code extracted from Photo Scene Editor that uploads photos to Photofly and asks for them to be stitched together into a scene on the server.

While we’re working to tidy this little executable up for publishing, I realised that a good portion of the application could be used as it stands: rather than uploading the photos directly from AutoCAD to Photofly, we can simply use the IP command directly to select the RZI file that has been downloaded for a particular photo scene using Photo Scene Editor. This simply means an updated IP command – a command that was previously only called internally – which now shows a dialog to select an RZI file when called interactively with FILEDIA set to 1.

The previous implementation of the application should be able to use this new version of the command as-is, although it may choose to delete the temporary RZI file on completion (something we don’t want for this version).

Here is the updated, stripped down C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

using System.Reflection;

using System.IO;

using System.Xml.Xsl;

using System.Diagnostics;

using System;

 

namespace ImportPhotofly

{

  public class Commands

  {

    [CommandMethod("IP")]

    public void ImportFromPhotofly()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      PromptOpenFileOptions opts =

        new PromptOpenFileOptions(

          "Select an RZI file returned from Photofly"

        );

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

      short ca = (short)Application.GetSystemVariable("CMDACTIVE");

 

      // Use the command-line version is FILEDIA is 0 or

      // CMDACTIVE indicates we're being called from a script

      // or from LISP

 

      opts.PreferCommandLine = (fd == 0 || (ca & 36) > 0);

      opts.Filter =

        "RZI (*.rzi)|*.rzi|All files (*.*)|*.*";

      PromptFileNameResult pr = ed.GetFileNameForOpen(opts);

 

      if (pr.Status != PromptStatus.OK)

        return;

 

      string rziPath = pr.StringResult;

      string name = Path.GetFileNameWithoutExtension(rziPath);

 

      // Paths for our temporary files

 

      string localPath = Path.GetDirectoryName(rziPath) + "\\";

 

      string txtPath = localPath + "points.txt";

      string lasPath = localPath + "points.las";

 

      // Our PCG file will be stored under My Documents

 

      string outputPath =

        Environment.GetFolderPath(

          Environment.SpecialFolder.MyDocuments

        ) + "\\Photofly Point Clouds\\";

 

      if (!Directory.Exists(outputPath))

        Directory.CreateDirectory(outputPath);

 

      // We'll use the title as a base filename for the PCG,

      // but will use an incremented integer to get an unused

      // filename

 

      int cnt = 0;

      string pcgPath;

      do

      {

        pcgPath =

          outputPath + name +

          (cnt == 0 ? "" : cnt.ToString()) + ".pcg";

        cnt++;

      }

      while (File.Exists(pcgPath));     

 

      // The path to the txt2las tool will be the same as the

      // executing assembly (our DLL)

 

      string exePath =

        Path.GetDirectoryName(

          Assembly.GetExecutingAssembly().Location

        ) + "\\";

 

      if (!File.Exists(exePath + "txt2las.exe"))

      {

        ed.WriteMessage(

          "\nCould not find the txt2las tool: please make sure it " +

          "is in the same folder as the application DLL."

        );

        return;

      }

 

      ed.WriteMessage(

        "\nCreating a LAS from the downloaded points.\n"

      );

 

      if (File.Exists(rziPath))

      {

        string xslPath = exePath + "rzi2txt.xslt";

 

        XslCompiledTransform xct = new XslCompiledTransform();

        xct.Load(xslPath);

        xct.Transform(rziPath, txtPath);

      }

      else

      {

        ed.WriteMessage("\nScene not generated.");

      }

 

      if (File.Exists(txtPath))

      {

        // Use the txt2las utility to create a .LAS

        // file from our text file

 

        ProcessStartInfo psi =

          new ProcessStartInfo(

            exePath + "txt2las",

            "-i \"" + txtPath +

            "\" -o \"" + lasPath +

            "\" -parse xyz"

          );

        psi.CreateNoWindow = false;

        psi.WindowStyle = ProcessWindowStyle.Hidden;

 

        // Wait for the process to exit

 

        try

        {

          using (Process p = Process.Start(psi))

          {

            p.WaitForExit();

          }

        }

        catch

        { }

 

        // If there's a problem, we return

 

        if (!File.Exists(lasPath))

        {

          ed.WriteMessage(

            "\nError creating LAS file."

          );

          return;

        }

        File.Delete(txtPath);

 

        ed.WriteMessage(

          "Indexing the LAS and attaching the PCG.\n"

        );

 

        // Index the .LAS file, creating a .PCG

 

        string lasLisp = lasPath.Replace('\\', '/'),

              pcgLisp = pcgPath.Replace('\\', '/');

 

        doc.SendStringToExecute(

          "(command \"_.POINTCLOUDINDEX\" \"" +

          lasLisp + "\" \"" +

          pcgLisp + "\")(princ) ",

          false, false, false

        );

 

        // Attach the .PCG file

 

        doc.SendStringToExecute(

          "_.WAITFORFILE2 \"" +

          pcgLisp + "\" \"" +

          lasLisp + "\" " +

          "(command \"_.-POINTCLOUDATTACH\" \"" +

          pcgLisp +

          "\" \"0,0\" \"1\" \"0\")(princ) ",

          false, false, false

        );

 

        doc.SendStringToExecute(

          "_.ZOOM _E ",

          false, false, false

        );

      }

    }

 

    // Return whether a file is accessible

 

    private bool IsFileAccessible(string filename)

    {

      // If the file can be opened for exclusive access it means

      // the file is accesible

      try

      {

        FileStream fs =

          File.Open(

            filename, FileMode.Open,

            FileAccess.Read, FileShare.None

          );

        using (fs)

        {

          return true;

        }

      }

      catch (IOException)

      {

        return false;

      }

    }

 

    // A command which waits for a particular PCG file to exist

 

    [CommandMethod("WAITFORFILE2", CommandFlags.NoHistory)]

    public void WaitForFileToExist()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      PromptResult pr = ed.GetString("Enter path to PCG: ");

      if (pr.Status != PromptStatus.OK)

        return;

      string pcgPath = pr.StringResult.Replace('/', '\\');

 

      pr = ed.GetString("Enter path to LAS: ");

      if (pr.Status != PromptStatus.OK)

        return;

      string lasPath = pr.StringResult.Replace('/', '\\');

 

      ed.WriteMessage(

        "\nWaiting for PCG creation to complete...\n"

      );

 

      // Check the write time for the PCG file...

      // if it hasn't been written to for at least half a second,

      // then we try to use a file lock to see whether the file

      // is accessible or not

 

      const int ticks = 50;

      TimeSpan diff;

 

      // First loop is to see when writing has stopped

      // (better than always throwing exceptions)

 

      while (true)

      {

        if (File.Exists(pcgPath))

        {

          DateTime dt = File.GetLastWriteTime(pcgPath);

          diff = DateTime.Now - dt;

          if (diff.Ticks > ticks)

            break;

        }

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

      }

 

      // Second loop will wait until file is finally accessible

      // (by calling a function that requests an exclusive lock)

 

      int inacc = 0;

      while (true)

      {

        if (IsFileAccessible(pcgPath))

          break;

        else

          inacc++;

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

      }

      ed.WriteMessage("\nFile inaccessible {0} times.", inacc);

 

      try

      {

        CleanupTmpFiles(lasPath);

      }

      catch

      { }

    }

 

    private void CleanupTmpFiles(string txtPath)

    {

      if (File.Exists(txtPath))

        File.Delete(txtPath);

      Directory.Delete(

        Path.GetDirectoryName(txtPath)

      );

    }

  }

}

First let’s use Photo Scene Editor to create – and edit, should we so desire, an advantage over the “one-click” approach – a photo scene:

Now when we execute the IP command, we get prompted to select an RZI file:

And we end up with our chapel’s point cloud inside AutoCAD:

The plugin implementing the IP command also requires the XSLT file shown in the prior post, as well as the TXT2LAS tool to generate a LAS file from the TXT output of the XSLT transformation process. Because of this added complexity, I’ve zipped the various files up for you to test and download directly.

One final comment… I should probably have mentioned that the Photo Scene Editor already allows export to DWG. This export is unfortunately a set of separate point objects, which is the main reason for using this alternative approach to get a true AutoCAD point cloud. We will be updating Photo Scene Editor’s existing export implementation, in due course.