Through the Interface: February 2011

Sun	Mon	Tue	Wed	Thu	Fri	Sat
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

« January 2011 | Main | March 2011 »

February 2011

February 28, 2011

Implementing drag & drop of an AutoCAD raster image at a specified location and size using .NET

I’m in Las Vegas, running between meetings, presentations and performance reviews, so just a quick post, today (it’s just before midnight here, but already Monday morning in Europe).

I promised in the last post and the one before that I’d extend the code we’ve been looking at to enable drag & drop of raster images into AutoCAD with resizing of the dropped image via a jig, using the code in this previous post as a foundation.

The below C# code does just that, with the new/modified lines in red (and the complete, unnumbered source file here):

    1 using Autodesk.AutoCAD.ApplicationServices;
    2 using Autodesk.AutoCAD.DatabaseServices;
    3 using Autodesk.AutoCAD.EditorInput;
    4 using Autodesk.AutoCAD.Geometry;
    5 using Autodesk.AutoCAD.Runtime;
    6 using Autodesk.AutoCAD.Windows;
    7 using System.Runtime.InteropServices;
    8 using System.Windows.Forms;
    9 using System.Drawing;
   10 using System.IO;
   11 using System;
   12 
   13 namespace DragAndDrop
   14 {
   15   public enum Msgs
   16   {
   17     WM_DRAWCLIPBOARD = 0x0308,
   18     WM_CHANGECBCHAIN = 0x030D
   19   }
   20 
   21   public class ClipboardView : UserControl
   22   {
   23     [DllImport("user32.dll")]
   24     public static extern IntPtr SetClipboardViewer(
   25       IntPtr hWndNewViewer
   26     );
   27 
   28     [DllImport("user32.dll", CharSet = CharSet.Auto)]
   29     public static extern IntPtr SendMessage(
   30       IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam
   31     );
   32 
   33     private IntPtr _nxtVwr;
   34     private PictureBox _img;
   35     private PaletteSet _ps;
   36 
   37     public System.Drawing.Image Contents
   38     {
   39       get { return _img.Image; }
   40     }
   41 
   42     public ClipboardView(PaletteSet ps)
   43     {
   44       _img = new PictureBox();
   45       _img.Anchor =
   46         (AnchorStyles)(AnchorStyles.Top |
   47                       AnchorStyles.Bottom |
   48                       AnchorStyles.Left |
   49                       AnchorStyles.Right);
   50       _img.Location = new Point(0, 0);
   51       _img.Size = this.Size;
   52       _img.SizeMode = PictureBoxSizeMode.StretchImage;
   53       Controls.Add(_img);
   54 
   55       // Add our event handler to launch a new drag event
   56       // when someone clicks on the control
   57 
   58       _img.MouseDown +=
   59         delegate(object sender, MouseEventArgs e)
   60         {
   61           // Simply initiate the drag & drop in AutoCAD,
   62           // specifying an instance of our custom "drop
   63           // target" class
   64 
   65           Autodesk.AutoCAD.ApplicationServices.
   66           Application.DoDragDrop(
   67             _img, this.Contents, DragDropEffects.Copy,
   68             new MyDropTarget()
   69           );
   70         };
   71 
   72       _nxtVwr = SetClipboardViewer(this.Handle);
   73       _ps = ps;
   74     }
   75 
   76     private void ExtractImage()
   77     {
   78       IDataObject iData;
   79       try
   80       {
   81         iData = Clipboard.GetDataObject();
   82       }
   83       catch (System.Exception ex)
   84       {
   85         MessageBox.Show(ex.ToString());
   86         return;
   87       }
   88 
   89       if (iData.GetDataPresent("Bitmap"))
   90       {
   91         object o = iData.GetData("Bitmap");
   92         Bitmap b = o as Bitmap;
   93         if (b != null)
   94         {
   95           _img.Image = b;
   96           if (_ps != null)
   97           {
   98             _ps.Size =
   99               new Size(b.Size.Width / 3, b.Size.Height / 3);
  100           }
  101         }
  102       }
  103     }
  104 
  105     protected override void WndProc(ref Message m)
  106     {
  107       switch ((Msgs)m.Msg)
  108       {
  109         case Msgs.WM_DRAWCLIPBOARD:
  110           ExtractImage();
  111           SendMessage(_nxtVwr, m.Msg, m.WParam, m.LParam);
  112           break;
  113         case Msgs.WM_CHANGECBCHAIN:
  114           if (m.WParam == _nxtVwr)
  115             _nxtVwr = m.LParam;
  116           else
  117             SendMessage(_nxtVwr, m.Msg, m.WParam, m.LParam);
  118           break;
  119         default:
  120           base.WndProc(ref m);
  121           break;
  122       }
  123     }
  124   }
  125 
  126   // Our custom drop target class
  127 
  128   public class MyDropTarget : DropTarget
  129   {
  130     public override void OnDrop(DragEventArgs e)
  131     {
  132       Document doc =
  133         Autodesk.AutoCAD.ApplicationServices.Application.
  134         DocumentManager.MdiActiveDocument;
  135 
  136       // If we have a valid bitmap, save it and send
  137       // our custom command (RINS)
  138 
  139       if (e.Data.GetDataPresent("Bitmap"))
  140       {
  141         object o = e.Data.GetData("Bitmap");
  142         Bitmap b = o as Bitmap;
  143         if (b != null)
  144         {
  145           // We'll save the bitmap as a "temp" file
  146           // (as its unique - a better approach
  147           // would probably to create a unique file
  148           // in the same folder as the drawing, but
  149           // that's left to the reader)
  150 
  151           string path = Path.GetTempFileName();
  152           b.Save(path);
  153 
  154           // Call our command
  155 
  156           string cmd =
  157             String.Format(
  158               "_RINS {0}\n{1},{2},0\n", path, e.X, e.Y
  159             );
  160           doc.SendStringToExecute(
  161             cmd, false, false, false
  162           );
  163         }
  164       }
  165     }
  166   }
  167 
  168   public class Commands
  169   {
  170     private PaletteSet _ps = null;
  171     private ClipboardView _cv = null;
  172     static private Point3d _pt = Point3d.Origin;
  173 
  174     [CommandMethod("DRAGDROP")]
  175     public void DragAndDropClipboardRaster()
  176     {
  177       if (_ps == null)
  178       {
  179         _ps = new PaletteSet(
  180           "DRAGDROP",
  181           new Guid("5C8FC28C-45ED-4796-BD40-28D235B6D7DA")
  182         );
  183 
  184         if (_cv == null)
  185         {
  186           _cv = new ClipboardView(_ps);
  187         }
  188 
  189         _ps.Text = "Clipboard";
  190         _ps.DockEnabled =
  191           DockSides.Left | DockSides.Right | DockSides.None;
  192         _ps.Size = new System.Drawing.Size(300, 500);
  193         _ps.Add("ClipboardView", _cv);
  194       }
  195       _ps.Visible = true;
  196     }
  197 
  198 
  199     // Our custom command to insert a raster image
  200 
  201     [CommandMethod("RINS")]
  202     public void RasterInsert()
  203     {
  204       Document doc =
  205       Autodesk.AutoCAD.ApplicationServices.Application.
  206       DocumentManager.MdiActiveDocument;
  207       Database db = doc.Database;
  208       Editor ed = doc.Editor;
  209 
  210       // Pick up the location of the bitmap image
  211 
  212       PromptStringOptions pso =
  213         new PromptStringOptions(
  214           "\nPath of raster image: "
  215         );
  216       pso.AllowSpaces = true;
  217       PromptResult pr = ed.GetString(pso);
  218       if (pr.Status != PromptStatus.OK)
  219         return;
  220 
  221       if (!File.Exists(pr.StringResult))
  222       {
  223         ed.WriteMessage(
  224           "\nFile does not exist."
  225         );
  226         return;
  227       }
  228 
  229       string path = pr.StringResult;
  230 
  231       // Pick up the position of the drop in screen coords
  232 
  233       PromptPointOptions ppo =
  234         new PromptPointOptions(
  235           "\nPosition of raster image: "
  236         );
  237       PromptPointResult ppr = ed.GetPoint(ppo);
  238       if (pr.Status != PromptStatus.OK)
  239         return;
  240 
  241       Point3d pos = ppr.Value;
  242 
  243       // Calculate the displacement vector
  244 
  245       Point3d pt =
  246         ed.PointToWorld(new Point((int)pos.X, (int)pos.Y));
  247       Matrix3d disp =
  248         Matrix3d.Displacement(pt - Point3d.Origin);
  249 
  250       Transaction tr =
  251         db.TransactionManager.StartTransaction();
  252       using (tr)
  253       {
  254         // Get or create our raster image dictionary
  255 
  256         ObjectId dictId =
  257           RasterImageDef.GetImageDictionary(db);
  258         if (dictId == ObjectId.Null)
  259           dictId = RasterImageDef.CreateImageDictionary(db);
  260 
  261         // And open it for write
  262 
  263         DBDictionary dict =
  264           (DBDictionary)tr.GetObject(
  265             dictId, OpenMode.ForWrite
  266           );
  267 
  268         // Get a unique name for our definition object
  269 
  270         string name = RasterImageDef.SuggestName(dict, path);
  271 
  272         // Create the definition and add it to the dictionary
  273 
  274         RasterImageDef rid = new RasterImageDef();
  275         rid.SourceFileName = path;
  276         rid.Load();
  277         ObjectId ridId = dict.SetAt(name, rid);
  278         tr.AddNewlyCreatedDBObject(rid, true);
  279 
  280         // Now we'll add our raster image reference
  281         // to the current space
  282 
  283         BlockTableRecord btr =
  284           (BlockTableRecord)tr.GetObject(
  285             db.CurrentSpaceId,
  286             OpenMode.ForWrite
  287           );
  288 
  289         // Call our jig to define the raster
  290 
  291         RasterJig jig =
  292           new RasterJig(
  293             ridId,
  294             rid.Size,
  295             ed.CurrentUserCoordinateSystem,
  296             pt
  297           );
  298         PromptResult prj = ed.Drag(jig);
  299 
  300         if (prj.Status != PromptStatus.OK)
  301         {
  302           rid.Erase();
  303           return;
  304         }
  305 
  306         // Get our entity and add it to the modelspace
  307 
  308         RasterImage ri = (RasterImage)jig.GetEntity();
  309         ri.ImageDefId = ridId;
  310         ri.SetClipBoundaryToWholeImage();
  311         btr.AppendEntity(ri);
  312         tr.AddNewlyCreatedDBObject(ri, true);
  313 
  314         // Create a reactor between the RasterImage and the
  315         // RasterImageDef to avoid the "unreferenced" 
  316         // warning in the XRef palette
  317 
  318         RasterImage.EnableReactors(true);
  319         ri.AssociateRasterDef(rid);
  320 
  321         // Of course we commit
  322 
  323         tr.Commit();
  324       }
  325     }
  326   }
  327 
  328   class RasterJig : EntityJig
  329   {
  330     Matrix3d _ucs;
  331     Vector2d _sz;
  332     Point3d _start = Point3d.Origin;
  333     Point3d _end = Point3d.Origin;
  334 
  335     public RasterJig(
  336       ObjectId defId,
  337       Vector2d sz,
  338       Matrix3d ucs,
  339       Point3d start
  340     )
  341       : base(new RasterImage())
  342     {
  343       _sz = sz;
  344       _start = start;
  345       _ucs = ucs;
  346 
  347       RasterImage ri = (RasterImage)Entity;
  348       ri.ImageDefId = defId;
  349 
  350       // Create a near zero size default image,
  351       // to avoid the boundary flicker
  352 
  353       double size = Tolerance.Global.EqualPoint;
  354       ri.Orientation =
  355         new CoordinateSystem3d(
  356           _start,
  357           new Vector3d(size, 0, 0),
  358           new Vector3d(0, size, 0)
  359         );
  360       ri.ShowImage = true;
  361     }
  362 
  363     protected override SamplerStatus Sampler(
  364       JigPrompts prompts
  365     )
  366     {
  367       JigPromptPointOptions opts =
  368         new JigPromptPointOptions();
  369       opts.UserInputControls =
  370         (UserInputControls.Accept3dCoordinates |
  371         UserInputControls.NoNegativeResponseAccepted);
  372       opts.Message = "\nSecond corner of raster image: ";
  373 
  374       // Get the point itself
  375 
  376       PromptPointResult res = prompts.AcquirePoint(opts);
  377 
  378       if (res.Status == PromptStatus.OK)
  379       {
  380         // Convert the supplied point into UCS
  381 
  382         Point3d tmp =
  383           res.Value.TransformBy(_ucs.Inverse());
  384 
  385         // Check if changed (reduces flicker)
  386 
  387         if (_end == tmp)
  388         {
  389           return SamplerStatus.NoChange;
  390         }
  391         else
  392         {
  393           _end = tmp;
  394           return SamplerStatus.OK;
  395         }
  396       }
  397       return SamplerStatus.Cancel;
  398     }
  399 
  400     protected override bool Update()
  401     {
  402       RasterImage ri = (RasterImage)Entity;
  403 
  404       // Get offset between the two corners
  405 
  406       Vector3d diff = _end - _start;
  407 
  408       // Get the ratios of the dimensions of the dragged
  409       // image with the source
  410 
  411       double sizeX = Math.Abs(diff.X),
  412             sizeY = Math.Abs(diff.Y),
  413             ratX = sizeX / _sz.X,
  414             ratY = sizeY / _sz.Y;
  415 
  416       // Find out which is bigger and use that to decide
  417       // which size should change to keep the proportion
  418 
  419       bool biggerX = (ratX > ratY);
  420 
  421       if (biggerX)
  422         sizeY = ratX * _sz.Y;
  423       else
  424         sizeX = ratY * _sz.X;
  425 
  426       // Determine the image's orientation...
  427 
  428       // The original will depend on the order of the corners
  429       // It will be offset to the left and/or down depending
  430       // on the values of the vector between the two points
  431 
  432       Point3d orig;
  433 
  434       // The axes stay the same, as we will always keep the
  435       // image oriented the same way relative to the UCS
  436 
  437       Vector3d xAxis = new Vector3d(sizeX, 0, 0);
  438       Vector3d yAxis = new Vector3d(0, sizeY, 0);
  439 
  440       if (diff.X > 0 && diff.Y > 0) // Dragging top-right
  441         orig = _start;
  442       else if (diff.X < 0 && diff.Y > 0) // Top-left
  443         orig = _start + new Vector3d(-sizeX, 0, 0);
  444       else if (diff.X > 0 && diff.Y < 0) // Bottom-right
  445         orig = _start + new Vector3d(0, -sizeY, 0);
  446       else // if (diff.X < 0 && diff.Y < 0) // Bottom-left
  447         orig = _start - new Vector3d(sizeX, sizeY, 0);
  448 
  449       // Set the image's orientation in WCS
  450 
  451       ri.Orientation =
  452         new CoordinateSystem3d(
  453           orig.TransformBy(_ucs),
  454           xAxis.TransformBy(_ucs),
  455           yAxis.TransformBy(_ucs)
  456         );
  457 
  458       return true;
  459     }
  460 
  461     public Entity GetEntity()
  462     {
  463       return Entity;
  464     }
  465   }
  466 }

When we run the new DRAGDROP command and drag & drop from our palette onto the drawing, we see the raster images are now inserted and sized by the jig proportionally to the original image’s size:

Posted at 09:05 AM in AutoCAD, AutoCAD .NET, User interface | Permalink | Comments (2)

February 25, 2011

Implementing drag & drop at a specific location in AutoCAD using .NET

As a follow up to the last post, here’s the update that places the dropped content at the cursor location. I‘ve been busy in meetings for most of the week, so I haven’t yet had time to integrate the jig for sizing.

Thanks for Mike Schumacher for pointing me at Editor.PointToWorld() (I’m not sure how I managed to miss it – let’s blame it on the jetlag).

Here’s the updated C# code with the new/modified lines in red (and the complete, unnumbered source file here):

    1 using Autodesk.AutoCAD.ApplicationServices;
    2 using Autodesk.AutoCAD.DatabaseServices;
    3 using Autodesk.AutoCAD.EditorInput;
    4 using Autodesk.AutoCAD.Geometry;
    5 using Autodesk.AutoCAD.Runtime;
    6 using Autodesk.AutoCAD.Windows;
    7 using System.Runtime.InteropServices;
    8 using System.Windows.Forms;
    9 using System.Drawing;
   10 using System.IO;
   11 using System;
   12 
   13 namespace DragAndDrop
   14 {
   15   public enum Msgs
   16   {
   17     WM_DRAWCLIPBOARD = 0x0308,
   18     WM_CHANGECBCHAIN = 0x030D
   19   }
   20 
   21   public class ClipboardView : UserControl
   22   {
   23     [DllImport("user32.dll")]
   24     public static extern IntPtr SetClipboardViewer(
   25       IntPtr hWndNewViewer
   26     );
   27 
   28     [DllImport("user32.dll", CharSet = CharSet.Auto)]
   29     public static extern IntPtr SendMessage(
   30       IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam
   31     );
   32 
   33     private IntPtr _nxtVwr;
   34     private PictureBox _img;
   35     private PaletteSet _ps;
   36 
   37     public System.Drawing.Image Contents
   38     {
   39       get { return _img.Image; }
   40     }
   41 
   42     public ClipboardView(PaletteSet ps)
   43     {
   44       _img = new PictureBox();
   45       _img.Anchor =
   46         (AnchorStyles)(AnchorStyles.Top |
   47                       AnchorStyles.Bottom |
   48                       AnchorStyles.Left |
   49                       AnchorStyles.Right);
   50       _img.Location = new Point(0, 0);
   51       _img.Size = this.Size;
   52       _img.SizeMode = PictureBoxSizeMode.StretchImage;
   53       Controls.Add(_img);
   54 
   55       // Add our event handler to launch a new drag event
   56       // when someone clicks on the control
   57 
   58       _img.MouseDown +=
   59         delegate(object sender, MouseEventArgs e)
   60         {
   61           // Simply initiate the drag & drop in AutoCAD,
   62           // specifying an instance of our custom "drop
   63           // target" class
   64 
   65           Autodesk.AutoCAD.ApplicationServices.
   66           Application.DoDragDrop(
   67             _img, this.Contents, DragDropEffects.Copy,
   68             new MyDropTarget()
   69           );
   70         };
   71 
   72       _nxtVwr = SetClipboardViewer(this.Handle);
   73       _ps = ps;
   74     }
   75 
   76     private void ExtractImage()
   77     {
   78       IDataObject iData;
   79       try
   80       {
   81         iData = Clipboard.GetDataObject();
   82       }
   83       catch (System.Exception ex)
   84       {
   85         MessageBox.Show(ex.ToString());
   86         return;
   87       }
   88 
   89       if (iData.GetDataPresent("Bitmap"))
   90       {
   91         object o = iData.GetData("Bitmap");
   92         Bitmap b = o as Bitmap;
   93         if (b != null)
   94         {
   95           _img.Image = b;
   96           if (_ps != null)
   97           {
   98             _ps.Size =
   99               new Size(b.Size.Width / 3, b.Size.Height / 3);
  100           }
  101         }
  102       }
  103     }
  104 
  105     protected override void WndProc(ref Message m)
  106     {
  107       switch ((Msgs)m.Msg)
  108       {
  109         case Msgs.WM_DRAWCLIPBOARD:
  110           ExtractImage();
  111           SendMessage(_nxtVwr, m.Msg, m.WParam, m.LParam);
  112           break;
  113         case Msgs.WM_CHANGECBCHAIN:
  114           if (m.WParam == _nxtVwr)
  115             _nxtVwr = m.LParam;
  116           else
  117             SendMessage(_nxtVwr, m.Msg, m.WParam, m.LParam);
  118           break;
  119         default:
  120           base.WndProc(ref m);
  121           break;
  122       }
  123     }
  124   }
  125 
  126   // Our custom drop target class
  127 
  128   public class MyDropTarget : DropTarget
  129   {
  130     public override void OnDrop(DragEventArgs e)
  131     {
  132       Document doc =
  133         Autodesk.AutoCAD.ApplicationServices.Application.
  134         DocumentManager.MdiActiveDocument;
  135 
  136       // If we have a valid bitmap, save it and send
  137       // our custom command (RINS)
  138 
  139       if (e.Data.GetDataPresent("Bitmap"))
  140       {
  141         object o = e.Data.GetData("Bitmap");
  142         Bitmap b = o as Bitmap;
  143         if (b != null)
  144         {
  145           // We'll save the bitmap as a "temp" file
  146           // (as its unique - a better approach
  147           // would probably to create a unique file
  148           // in the same folder as the drawing, but
  149           // that's left to the reader)
  150 
  151           string path = Path.GetTempFileName();
  152           b.Save(path);
  153 
  154           // Call our command
  155 
  156           string cmd =
  157             String.Format(
  158               "_RINS {0}\n{1},{2},0\n", path, e.X, e.Y
  159             );
  160           doc.SendStringToExecute(
  161             cmd, false, false, false
  162           );
  163         }
  164       }
  165     }
  166   }
  167 
  168   public class Commands
  169   {
  170     private PaletteSet _ps = null;
  171     private ClipboardView _cv = null;
  172     static private Point3d _pt = Point3d.Origin;
  173 
  174     [CommandMethod("DRAGDROP")]
  175     public void DragAndDropClipboardRaster()
  176     {
  177       if (_ps == null)
  178       {
  179         _ps = new PaletteSet(
  180           "DRAGDROP",
  181           new Guid("5C8FC28C-45ED-4796-BD40-28D235B6D7DA")
  182         );
  183 
  184         if (_cv == null)
  185         {
  186           _cv = new ClipboardView(_ps);
  187         }
  188 
  189         _ps.Text = "Clipboard";
  190         _ps.DockEnabled =
  191           DockSides.Left | DockSides.Right | DockSides.None;
  192         _ps.Size = new System.Drawing.Size(300, 500);
  193         _ps.Add("ClipboardView", _cv);
  194       }
  195       _ps.Visible = true;
  196     }
  197 
  198 
  199     // Our custom command to insert a raster image
  200 
  201     [CommandMethod("RINS")]
  202     public void RasterInsert()
  203     {
  204       Document doc =
  205       Autodesk.AutoCAD.ApplicationServices.Application.
  206       DocumentManager.MdiActiveDocument;
  207       Database db = doc.Database;
  208       Editor ed = doc.Editor;
  209 
  210       // Pick up the location of the bitmap image
  211 
  212       PromptStringOptions pso =
  213         new PromptStringOptions(
  214           "\nPath of raster image: "
  215         );
  216       pso.AllowSpaces = true;
  217       PromptResult pr = ed.GetString(pso);
  218       if (pr.Status != PromptStatus.OK)
  219         return;
  220 
  221       if (!File.Exists(pr.StringResult))
  222       {
  223         ed.WriteMessage(
  224           "\nFile does not exist."
  225         );
  226         return;
  227       }
  228 
  229       string path = pr.StringResult;
  230 
  231       // Pick up the position of the drop in screen coords
  232 
  233       PromptPointOptions ppo =
  234         new PromptPointOptions(
  235           "\nPosition of raster image: "
  236         );
  237       PromptPointResult ppr = ed.GetPoint(ppo);
  238       if (pr.Status != PromptStatus.OK)
  239         return;
  240 
  241       Point3d pos = ppr.Value;
  242 
  243       // Calculate the displacement vector
  244 
  245       Point3d pt =
  246         ed.PointToWorld(new Point((int)pos.X, (int)pos.Y));
  247       Matrix3d disp =
  248         Matrix3d.Displacement(pt - Point3d.Origin);
  249 
  250       Transaction tr =
  251         db.TransactionManager.StartTransaction();
  252       using (tr)
  253       {
  254         // Get or create our raster image dictionary
  255 
  256         ObjectId dictId =
  257           RasterImageDef.GetImageDictionary(db);
  258         if (dictId == ObjectId.Null)
  259           dictId = RasterImageDef.CreateImageDictionary(db);
  260 
  261         // And open it for write
  262 
  263         DBDictionary dict =
  264           (DBDictionary)tr.GetObject(
  265             dictId, OpenMode.ForWrite
  266           );
  267 
  268         // Get a unique name for our definition object
  269 
  270         string name = RasterImageDef.SuggestName(dict, path);
  271 
  272         // Create the definition and add it to the dictionary
  273 
  274         RasterImageDef rid = new RasterImageDef();
  275         rid.SourceFileName = path;
  276         rid.Load();
  277         ObjectId ridId = dict.SetAt(name, rid);
  278         tr.AddNewlyCreatedDBObject(rid, true);
  279 
  280         // Now we'll add our raster image reference
  281         // to the current space
  282 
  283         BlockTableRecord btr =
  284           (BlockTableRecord)tr.GetObject(
  285             db.CurrentSpaceId,
  286             OpenMode.ForWrite
  287           );
  288 
  289         // Create and add the image reference
  290 
  291         RasterImage ri = new RasterImage();
  292         ri.ImageDefId = ridId;
  293         ri.SetClipBoundaryToWholeImage();
  294         btr.AppendEntity(ri);
  295         tr.AddNewlyCreatedDBObject(ri, true);
  296         ri.TransformBy(disp);
  297 
  298         // Of course we commit
  299 
  300         tr.Commit();
  301       }
  302     }
  303   }
  304 }

The changes, as you can see, are very modest: the SendStringToExecute() call now sends the point in screen coordinates (adding a zero for Z, just to simplify collection by the command). The command collects and transforms the point before creating a displacement vector to apply to the raster image reference. The matrix gets applied to the image after it has been added to the drawing, but we could very well do so beforehand.

The code now allows the user to drop images from our palette at specific locations in the drawing:

I’m heading off to Las Vegas in the morning, but will hopefully still have time to post the jig update at the beginning of next week.

Posted at 08:19 AM | Permalink | Comments (0)

February 23, 2011

Managing drag & drop from a palette into AutoCAD using .NET

I’m up early (after sleeping late) with jetlag, so I thought I may as well put together this post. My brain isn’t fully functional, I suspect, so forgive any errors (but please let me know about them, so I can fix them :-).

I was inspired to implement the code in this post by an internal email thread, wherein Albert Szilvasy recommended implementing a comparable technique to a colleague. Please don’t blame Albert for the implementation details, though, they are all mine.

The idea is simple: you have some kind of modeless PaletteSet, and you want to initiate and manage a drag & drop of some kind of custom content from the palette into AutoCAD. In this case – to get started quickly – I took the code from this previous post, which displayed a palette previewing the contents of the Windows clipboard for eventual inclusion in the Clipboard Manager Plugin of the Month.

In this example we have a bitmap hosted in a palette: when someone clicks on the image, we’ll start our drag operation, and should the drag leave the palette and enter AutoCAD’s drawing window, we’ll respond to the eventual drop by saving the image in the palette as a bitmap to file and firing a command inside AutoCAD with the location of the bitmap. Once again there’s our important rule of thumb when it comes to implementing a modeless UI: rather than manually locking the current document, it’s safer to define a command – which will implicitly lock the current document – and call that from the UI via SendStringToExecute().

The custom command we call – named RINS – will simply add a raster image to the AutoCAD drawing in the current space.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Windows;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Drawing;
using System.IO;
using System;
 
namespace DragAndDrop
{
  public enum Msgs
  {
    WM_DRAWCLIPBOARD = 0x0308,
    WM_CHANGECBCHAIN = 0x030D
  }
 
  public class ClipboardView : UserControl
  {
    [DllImport("user32.dll")]
    public static extern IntPtr SetClipboardViewer(
      IntPtr hWndNewViewer
    );
 
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    public static extern IntPtr SendMessage(
      IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam
    );
 
    private IntPtr _nxtVwr;
    private PictureBox _img;
    private PaletteSet _ps;
 
    public System.Drawing.Image Contents
    {
      get { return _img.Image; }
    }
 
    public ClipboardView(PaletteSet ps)
    {
      _img = new PictureBox();
      _img.Anchor =
        (AnchorStyles)(AnchorStyles.Top |
                      AnchorStyles.Bottom |
                      AnchorStyles.Left |
                      AnchorStyles.Right);
      _img.Location = new Point(0, 0);
      _img.Size = this.Size;
      _img.SizeMode = PictureBoxSizeMode.StretchImage;
      Controls.Add(_img);
 
      // Add our event handler to launch a new drag event
      // when someone clicks on the control
 
      _img.MouseDown +=
        delegate(object sender, MouseEventArgs e)
        {
          // Simply initiate the drag & drop in AutoCAD,
          // specifying an instance of our custom "drop
          // target" class
 
          Autodesk.AutoCAD.ApplicationServices.
          Application.DoDragDrop(
            _img, this.Contents, DragDropEffects.Copy,
            new MyDropTarget()
          );
        };
 
      _nxtVwr = SetClipboardViewer(this.Handle);
      _ps = ps;
    }
 
    private void ExtractImage()
    {
      IDataObject iData;
      try
      {
        iData = Clipboard.GetDataObject();
      }
      catch (System.Exception ex)
      {
        MessageBox.Show(ex.ToString());
        return;
      }
 
      if (iData.GetDataPresent("Bitmap"))
      {
        object o = iData.GetData("Bitmap");
        Bitmap b = o as Bitmap;
        if (b != null)
        {
          _img.Image = b;
          if (_ps != null)
          {
            _ps.Size =
              new Size(b.Size.Width / 3, b.Size.Height / 3);
          }
        }
      }
    }
 
    protected override void WndProc(ref Message m)
    {
      switch ((Msgs)m.Msg)
      {
        case Msgs.WM_DRAWCLIPBOARD:
          ExtractImage();
          SendMessage(_nxtVwr, m.Msg, m.WParam, m.LParam);
          break;
        case Msgs.WM_CHANGECBCHAIN:
          if (m.WParam == _nxtVwr)
            _nxtVwr = m.LParam;
          else
            SendMessage(_nxtVwr, m.Msg, m.WParam, m.LParam);
          break;
        default:
          base.WndProc(ref m);
          break;
      }
    }
  }
 
  // Our custom drop target class
 
  public class MyDropTarget : Autodesk.AutoCAD.Windows.DropTarget
  {
    public override void OnDrop(DragEventArgs e)
    {
      Document doc =
        Autodesk.AutoCAD.ApplicationServices.Application.
        DocumentManager.MdiActiveDocument;
 
      // If we have a valid bitmap, save it and send
      // our custom command (RINS)
 
      if (e.Data.GetDataPresent("Bitmap"))
      {
        object o = e.Data.GetData("Bitmap");
        Bitmap b = o as Bitmap;
        if (b != null)
        {
          // We'll save the bitmap as a "temp" file
          // (as its unique - a better approach
          // would probably to create a unique file
          // in the same folder as the drawing, but
          // that's left to the reader)
 
          string path = Path.GetTempFileName();
          b.Save(path);
 
          // Call our command
 
          string cmd = "_RINS " + path + "\n";
          doc.SendStringToExecute(
            cmd, false, false, false
          );
        }
      }
    }
  }
 
  public class Commands
  {
    private PaletteSet _ps = null;
    private ClipboardView _cv = null;
    static private Point3d _pt = Point3d.Origin;
 
    [CommandMethod("DRAGDROP")]
    public void DragAndDropClipboardRaster()
    {
      if (_ps == null)
      {
        _ps = new PaletteSet(
          "DRAGDROP",
          new Guid("5C8FC28C-45ED-4796-BD40-28D235B6D7DA")
        );
 
        if (_cv == null)
        {
          _cv = new ClipboardView(_ps);
        }
 
        _ps.Text = "Clipboard";
        _ps.DockEnabled =
          DockSides.Left | DockSides.Right | DockSides.None;
        _ps.Size = new System.Drawing.Size(300, 500);
        _ps.Add("ClipboardView", _cv);
      }
      _ps.Visible = true;
    }
 
 
    // Our custom command to insert a raster image
 
    [CommandMethod("RINS")]
    public void RasterInsert()
    {
      Document doc =
      Autodesk.AutoCAD.ApplicationServices.Application.
      DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Pick up the location of the bitmap image
 
      PromptStringOptions pso =
        new PromptStringOptions(
          "\nPath of raster image: "
        );
      pso.AllowSpaces = true;
      PromptResult pr = ed.GetString(pso);
      if (pr.Status != PromptStatus.OK)
        return;
 
      if (!File.Exists(pr.StringResult))
      {
        ed.WriteMessage(
          "\nFile does not exist."
        );
        return;
      }
 
      string path = pr.StringResult;
 
      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        // Get or create our raster image dictionary
 
        ObjectId dictId =
          RasterImageDef.GetImageDictionary(db);
        if (dictId == ObjectId.Null)
          dictId = RasterImageDef.CreateImageDictionary(db);
 
        // And open it for write
 
        DBDictionary dict =
          (DBDictionary)tr.GetObject(
            dictId, OpenMode.ForWrite
          );
 
        // Get a unique name for our definition object
 
        string name = RasterImageDef.SuggestName(dict, path);
 
        // Create the definition and add it to the dictionary
 
        RasterImageDef rid = new RasterImageDef();
        rid.SourceFileName = path;
        rid.Load();
        ObjectId ridId = dict.SetAt(name, rid);
        tr.AddNewlyCreatedDBObject(rid, true);
 
        // Now we'll add our raster image reference
        // to the current space
 
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            db.CurrentSpaceId,
            OpenMode.ForWrite
          );
 
        // Create and add the image reference
 
        RasterImage ri = new RasterImage();
        ri.ImageDefId = ridId;
        ri.SetClipBoundaryToWholeImage();
        btr.AppendEntity(ri);
        tr.AddNewlyCreatedDBObject(ri, true);
 
        // Of course we commit
 
        tr.Commit();
      }
    }
  }
}

Here’s what happens when we run the DRAGDROP command and copy a block to the clipboard:

As we click on the image to start the drag, we see the “not allowed” cursor:

As we drag onto the drawing canvas, we see the “drag a copy” cursor:

And as we drop we see the RINS command execute and our raster image get inserted at the origin of the drawing with the default size:

Where in this post we’re just passing the location (on disk) of the newly-saved image to the RINS command, in the next post I intend to extend the command to take the location of the drop as being the insertion point of the image and then prompt the user for the second corner. We’ll probably use the raster image jig from this previous post to help with that.

One problem I’m currently having (hopefully due to jetlag-related fogginess) is with translating the screen coordinates provided to the the drop target into a position inside AutoCAD (UCS or WCS, I don’t much care) at which we can create the raster image reference. If anyone knows a simple way to get from screen coordinates to some kind of drawing coordinates, please let me know. I’ve tried a point monitor, but that unfortunately only gets the cursor’s position in the drawing prior to entering the palette, rather than at the drop location.

Posted at 03:16 PM in AutoCAD, AutoCAD .NET, Notification / Events, User interface | Permalink | Comments (6)

February 22, 2011

Back in the Bay Area

Earlier today, while transiting between flights from Geneva to San Francisco in Heathrow, I overheard one security agent describing the perfect “pat down” to a colleague:

“You need to get them to hold their arms out wide. Not like that lady who kept her elbows by her sides, with her hands flapping around like one of those raptures [sic.] from Jurassic Park.”

I’ll be travelling over the next week or so, between San Francisco, San Rafael and Las Vegas. I’ll be posting on more technical topics, when I have time, but thought I’d share that little travel anecdote, in the meantime. :-)

Posted at 04:58 AM in Personal, Travel | Permalink | Comments (0)

February 18, 2011

Comparing Explode with ExplodeFragments on AutoCAD MText

This request was posted by Mike C as a comment on the last post:

Could you expand this article to handle MTEXT? It would be nice to contrast the Explode and ExplodeFragments methods.

As I hadn’t actually used MText.ExplodeFragments() before (at least not that I could remember), I thought it was indeed worth spending some time on today.

Before launching into the code, a few words on using Entity.Explode() or MText.ExplodeFragments(), specifically with respect to MText. Entity.Explode() works very well on MText objects: if you want to generate physical AutoCAD geometry from MText (in this case creating DBText objects or possibly a number of smaller MText objects, in the case of multi-column MText), then this is the way to go. MText.ExplodeFragments() is a good way to get at the data inside your MText – you get a function call reporting each line (or fragment) of your MText – and this is presumably quite handy for performing tasks such as stripping control codes, etc.

The below C# code extends the code in the last post to more explicitly deal with MText. It dumps the MText fragments found to the command-line, and optionally allows you to explode the MText entities anyway.

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
 
namespace Explosion
{
  public class Commands
  {
    [CommandMethod("EXP", CommandFlags.UsePickSet)]
    public void ExplodeEntities()
    {
      Document doc =
          Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask user to select entities
 
      PromptSelectionOptions pso =
        new PromptSelectionOptions();
      pso.MessageForAdding = "\nSelect objects to explode: ";
      pso.AllowDuplicates = false;
      pso.AllowSubSelections = true;
      pso.RejectObjectsFromNonCurrentSpace = true;
      pso.RejectObjectsOnLockedLayers = false;
 
      PromptSelectionResult psr = ed.GetSelection(pso);
      if (psr.Status != PromptStatus.OK)
        return;
 
      // Check whether to erase the original(s)
 
      bool eraseOrig = false,
          explodeMText = false;
 
      if (psr.Value.Count > 0)
      {
        PromptKeywordOptions pko =
          new PromptKeywordOptions("\nErase original objects?");
        pko.AllowNone = true;
        pko.Keywords.Add("Yes");
        pko.Keywords.Add("No");
        pko.Keywords.Default = "No";
 
        PromptResult pkr = ed.GetKeywords(pko);
        if (pkr.Status != PromptStatus.OK)
          return;
 
        eraseOrig = (pkr.StringResult == "Yes");
 
        pko.Message = "\nExplode MText?";
        pkr = ed.GetKeywords(pko);
        if (pkr.Status != PromptStatus.OK)
          return;
 
        explodeMText = (pkr.StringResult == "Yes");
      }
 
      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        // Collect our exploded objects in a single collection
 
        DBObjectCollection objs = new DBObjectCollection();
 
        // Loop through the selected objects
 
        foreach (SelectedObject so in psr.Value)
        {
          // Open one at a time
 
          Entity ent =
            (Entity)tr.GetObject(
              so.ObjectId,
              OpenMode.ForRead
            );
 
          // If dealing with MText...
 
          MText mt = ent as MText;
          if (mt != null)
          {
            // Create our callback method based on
            // a lambda expression (C# 3.0 or higher)
 
            MTextFragmentCallback cb =
              new MTextFragmentCallback(
                (frag, obj) =>
                {
                  // Great to see type inference working in C#, so
                  // IntelliSense treats frag as an MTextFragment
 
                  ed.WriteMessage(
                    "\nMText fragment found: {0}", frag.Text
                  );
                  return MTextFragmentCallbackStatus.Continue;
                }
              );
            mt.ExplodeFragments(cb);
          }
 
          // Only explode if not MText or we're also exploding
          // MText objects
 
          if (mt == null || explodeMText)
          {
            // Explode the object into our collection
 
            try
            {
              ent.Explode(objs);
            }
            catch { }
 
            // Erase the original, if requested
 
            if (eraseOrig)
            {
              ent.UpgradeOpen();
              ent.Erase();
            }
          }
        }
 
        // Now open the current space in order to
        // add our resultant objects
 
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            db.CurrentSpaceId,
            OpenMode.ForWrite
          );
 
        // Add each one of them to the current space
        // and to the transaction
 
        foreach (DBObject obj in objs)
        {
          Entity ent = (Entity)obj;
          btr.AppendEntity(ent);
          tr.AddNewlyCreatedDBObject(ent, true);
        }
 
        // And then we commit
 
        tr.Commit();
      }
    }
  }
} 

I decided to use a lambda expression – introduced in C# 3.0 – to implement our callback function which then gets wrapped in a MTextFragmentCallback object. This will mean a little extra work if supporting prior versions of C# or converting the code to VB.NET. I also added a try-catch block around the Explode() call, to pick up eNotApplicable exceptions and the like.

Let’s see what happens when we run the code, selecting the main MText object from the Sample/Mechanical Sample/Mechanical – Text and Tables.dwg sample drawing.

Here’s the selected MText – we can already see it contains a bunch of control codes from the contents property:

When we run the EXP command – choosing to both erase the original entities and explode MText (as well as the default behaviour of reporting the fragments) – we see these results on the command-line, with – quite importantly – not a control code in sight:

Command: EXP
Select objects to explode: 1 found
Select objects to explode:
Erase original objects? [Yes/No] <No>: Y
Explode MText? [Yes/No] <No>: Y
MText fragment found: GENERAL NOTES:
MText fragment found: 1.
MText fragment found: REFERENCE DRAWINGS ARE AS FOLLOWS:
MText fragment found: P & ID LEGEND
MText fragment found: SK-P-DR-0010
MText fragment found: GROUND LEVEL PLAN
MText fragment found: SK-F-DR-0001
MText fragment found: GENERAL NOTES ON CIVIL INTERFACE DRAWINGS
MText fragment found: SK-F-DR-0016
MText fragment found: STEAMFIELD LAYOUT
MText fragment found: SK-M-DR-0002
MText fragment found: SEPARATOR AREA - GENERAL ARRANGEMENT - PLAN
MText fragment found: SK-M-DR-0003
MText fragment found: SEPARATOR AREA - GENERAL ARRANGEMENT - ELEVATION
MText fragment found: SK-M-DR-0004
MText fragment found: PIPING KEY PLAN
MText fragment found: SK-M-DR-0010
MText fragment found: PIPING STANDARD DETAILS - CONDENSATE DRAIN POT
MText fragment found: SK-M-DR-0020
MText fragment found: PIPING STANDARD DETAILS - STEAM TRAP ASSEMBLY
MText fragment found: SK-M-DR-0021
MText fragment found: PIPING STANDARD DETAILS - HIGH POINT VENT
MText fragment found: SK-M-DR-0022
MText fragment found: PIPING STANDARD DETAILS - LOW POINT DRAIN
MText fragment found: SK-M-DR-0023
MText fragment found: PIPING STANDARD DETAILS - LOW POINT DRAIN (BRINE SYSTEM)
MText fragment found: SK-M-DR-0024
MText fragment found: PIPING STANDARD DETAILS - SAMPLE POINT
MText fragment found: STEAM AND CONDENSATE SERVICE
MText fragment found: SK-M-DR-0025
MText fragment found: PIPING STANDARD DETAILS - SAMPLE POINT
MText fragment found: CHEMICAL SERVICE
MText fragment found: SK-M-DR-0026
MText fragment found: PIPING STANDARD DETAILS -  ISOKINETIC SAMPLE PROBE
MText fragment found: SK-M-DR-0027
MText fragment found: PIPING STANDARD DETAILS -  PRESSURE TAPPING
MText fragment found:
MText fragment found: SK-M-DR-0028
MText fragment found: PIPING STANDARD DETAILS -  THERMOWELL
MText fragment found: SK-M-DR-0029
MText fragment found: PIPING STANDARD DETAILS -  ORIFICE PLATE
MText fragment found: SK-M-DR-0030
MText fragment found: PIPING STANDARD DETAILS -  SPRAY NOZZLE
MText fragment found:
MText fragment found: SK-M-DR-0031
MText fragment found: PIPING STANDARD DETAILS -  pH PROBE
MText fragment found: SK-M-DR-0032
MText fragment found: PIPING STANDARD DETAILS -  FLOW SWITCH
MText fragment found: SK-M-DR-0033
MText fragment found: PIPING STANDARD DETAILS -  SPRAY NOZZLE
MText fragment found: SK-M-DR-0034
MText fragment found: PIPING STANDARD DETAILS -  SPRAY NOZZLE
MText fragment found: SK-M-DR-0035
MText fragment found: PIPING STANDARD DETAILS -  STEAM ANALYZER
MText fragment found: SK-M-DR-0036
MText fragment found: INSULATION & CLADDING DETAILS
MText fragment found: SK-M-DR-0037, 0038 & 0039
MText fragment found: HP SEPARATOR - GENERAL NOTES AND NOZZLE LOADS
MText fragment found: SK-M-DR-0100
MText fragment found: HP SEPARATOR - GENERAL ARRANGEMENT
MText fragment found: SK-M-DR-0101
MText fragment found: HP SEPARATOR - INLET NOZZLE DETAIL
MText fragment found: SK-M-DR-0102
MText fragment found: HP SEPARATOR - INLET NOZZLE LEMNISCATE CURVE
MText fragment found: TEMPLATE DIMENSIONS
MText fragment found: SK-M-DR-0103
MText fragment found: LP SEPARATOR - GENERAL NOTES AND NOZZLE LOADS
MText fragment found: SK-M-DR-0110
MText fragment found: LP SEPARATOR - GENERAL ARRANGEMENT
MText fragment found: SK-M-DR-0111
MText fragment found: LP SEPARATOR - INLET NOZZLE DETAIL
MText fragment found: SK-M-DR-0112
MText fragment found: LP SEPARATOR - INLET NOZZLE LEMNISCATE CURVE
MText fragment found: TEMPLATE DIMENSIONS
MText fragment found: SK-M-DR-0113
MText fragment found: FLASH TANK - GENERAL ARRANGEMENT
MText fragment found: SK-M-DR-0120
MText fragment found: FLASH TANK - HOLD-DOWN BOLT GENERAL ARRANGEMENT
MText fragment found: SK-M-DR-0121
MText fragment found: FLASH TANK - WEIR BOX DETAILS
MText fragment found: SK-M-DR-0122
MText fragment found: FLASH TANK - NOZZLE DETAILS
MText fragment found: SK-M-DR-0123
MText fragment found: FLASH TANK - OTHER NOZZLE DETAILS
MText fragment found: SK-M-DR-0124
MText fragment found: FLASH TANK - BAFFLE PLATE DETAILS
MText fragment found: SK-M-DR-0125
MText fragment found: ACID STORAGE TANK - GENERAL ARRANGEMENT
MText fragment found: SK-M-DR-0130
MText fragment found: ACID STORAGE TANK - HOLD-DOWN BOLT GENERAL ARRANGEMENT
MText fragment found: SK-M-DR-0131
MText fragment found: ACID STORAGE TANK - NOZZLE DETAILS
MText fragment found: SK-M-DR-0132
MText fragment found: PIPE SUPPORTS - PIPE GUIDE TYPE PG1
MText fragment found: SK-M-DR-0250
MText fragment found: PIPE SUPPORTS - PIPE GUIDE TYPE PG2
MText fragment found: SK-M-DR-0251
MText fragment found: PIPE SUPPORTS - PIPE GUIDE TYPE PG3
MText fragment found: SK-M-DR-0252
MText fragment found: PIPE SUPPORTS - LINE STOP TYPE LS1
MText fragment found: SK-M-DR-0253
MText fragment found: PIPE SUPPORTS - LINE STOP TYPE LS2
MText fragment found: SK-M-DR-0254
MText fragment found: PIPE SUPPORTS - LINE STOP TYPE LS3
MText fragment found: SK-M-DR-0255
MText fragment found: PIPE SUPPORTS - PIPE ANCHOR TYPE PA1
MText fragment found: SK-M-DR-0256
MText fragment found: PIPE SUPPORTS - PIPE ANCHOR TYPE PA2
MText fragment found: SK-M-DR-0257
MText fragment found: PIPE SUPPORTS - PIPE ANCHOR TYPE PA3
MText fragment found: SK-M-DR-0258
MText fragment found: 2.
MText fragment found: PIPING SHALL BE IN ACCORDANCE WITH THE FOLLOWING 
SPECIFICATIONS:
MText fragment found: PIPE SPECIFICATION - CS TWO PHASE
MText fragment found: - XXXX
MText fragment found: SK-M-SP-0001
MText fragment found: PIPE SPECIFICATION - CS HP STEAM
MText fragment found: - XXXX
MText fragment found: SK-M-SP-0002
MText fragment found: PIPE SPECIFICATION - CS LP STEAM
MText fragment found: - XXXX
MText fragment found: SK-M-SP-0003
MText fragment found: PIPE SPECIFICATION - CS BRINE
MText fragment found:
MText fragment found: - XXXX
MText fragment found: SK-M-SP-0004
MText fragment found: PIPE SPECIFICATION - HDPE CONDENSATE
MText fragment found: - XXXX
MText fragment found: SK-M-SP-0005
MText fragment found: PIPE SPECIFICATION - SS CONDENSATE
MText fragment found: - XXXX
MText fragment found: SK-M-SP-0006
MText fragment found: PIPE SPECIFICATION - SS WASH WATER
MText fragment found: - XXXX
MText fragment found: SK-M-SP-0007
MText fragment found: PIPE SPECIFICATION - HASTELLOY ACID
MText fragment found: - XXXX
MText fragment found: SK-M-SP-0008
MText fragment found: 3.
MText fragment found: INSPECTION AND TESTING PIPING SHALL BE INSPECTED AND 
TESTED IN ACCORDANCE  WITH THE SPECIFIED
MText fragment found: CODE AS WELL AS THE FOLLOWING:
MText fragment found: A.
MText fragment found: 100% RADIOGRAPH FOR PRESSURE RETAINING WELDS
MText fragment found: B.
MText fragment found: ALL NON PRESSURE WELDS TO BE MAG PARTICLE OR DYE 
PENETRANT TESTED
MText fragment found: C.
MText fragment found: HYDROSTATIC TEST PRESSURE IN ACCORDANCE WITH ASME
MText fragment found: VIII DIVISION 1  PARAGRAPH UG-99(C)
MText fragment found: D.
MText fragment found: THE CONTRACTOR IS TO PROVIDE ANY BLIND FLANGES AND 
EQUIPMENT TO  UNDERTAKE THE
MText fragment found: TESTING
MText fragment found: REFER TO SPECIFICATION FOR HYDROSTATIC TESTING OF PIPES
MText fragment found: SK-M-SP-0024
MText fragment found: 4.
MText fragment found: PIPING LAYOUT DIMENSIONS ARE SHOWN IN MILLIMETERS, FOR 
THE PIPING &  WELLHEADS IN THE COLD
MText fragment found: POSITION. GRIDLINE COORDINATES AND ELEVATIONS ARE  IN 
METERS. PIPE DIAMETERS ARE SHOWN IN
MText fragment found: INCHES.
MText fragment found: 5.
MText fragment found: ELEVATIONS ARE GIVEN TO PIPE CENTERLINES UNLESS OTHERWISE 
NOTED.
MText fragment found: 6.
MText fragment found: ABBREVIATIONS:
MText fragment found: BE
MText fragment found: BEVELED ENDS
MText fragment found: O/D
MText fragment found: OUTSIDE DIAMETER
MText fragment found: BW
MText fragment found: BUTT WELD
MText fragment found: PBE
MText fragment found: PLAIN BOTH ENDS
MText fragment found: CDP
MText fragment found: CONDENSATE DRAIN POINT
MText fragment found: PFC
MText fragment found: PARALLEL FLANGED CHANNEL
MText fragment found: CS
MText fragment found: CARBON STEEL
MText fragment found: PL
MText fragment found: PLATE
MText fragment found: C/WT
MText fragment found: COUNTER WEIGHT
MText fragment found: POE
MText fragment found: PLAIN ONE END
MText fragment found: CENTER LINE
MText fragment found: PTA
MText fragment found: PRESSURE TAPPING
MText fragment found: CTRS
MText fragment found: CENTERS
MText fragment found: RF
MText fragment found: RAISED FACE
MText fragment found: CVR
MText fragment found: COVER
MText fragment found: RL
MText fragment found: REDUCED LEVEL
MText fragment found: COS
MText fragment found: CHECK ON SITE
MText fragment found: RO
MText fragment found: RESTRICTION ORIFICE
MText fragment found: C
MText fragment found: CHANNEL
MText fragment found: RSA
MText fragment found: ROLLED STEEL ANGLE
MText fragment found: E
MText fragment found: EAST
MText fragment found: RTJ
MText fragment found: RING TYPE JOINT
MText fragment found: EW
MText fragment found: EACH WAY
MText fragment found: SPA
MText fragment found: STEAM SAMPLING POINT
MText fragment found: FO
MText fragment found: FLOW ORIFICE
MText fragment found: STD
MText fragment found: STANDARD
MText fragment found: GALV
MText fragment found: GALVANIZED
MText fragment found: SAW
MText fragment found: SUBMERGED ARC WELDED
MText fragment found: HPV
MText fragment found: HIGH POINT VENT
MText fragment found: SMLS
MText fragment found: SEAMLESS
MText fragment found: IAC
MText fragment found: INSTRUMENT AIR CONNECTION
MText fragment found: SP
MText fragment found: SAMPLE  POINT
MText fragment found: IP
MText fragment found: INTERSECTION POINT
MText fragment found: SW
MText fragment found: SOCKET WELD
MText fragment found: IS
MText fragment found: ISOKINETIC SAMPLE POINT
MText fragment found: TBE
MText fragment found: THREADED BOTH ENDS
MText fragment found: L
MText fragment found: ANGLE
MText fragment found: THD
MText fragment found: THREADED
MText fragment found: LG
MText fragment found: LONG
MText fragment found: TOE
MText fragment found: THREADED ONE END
MText fragment found: LPD
MText fragment found: LOW POINT DRAIN
MText fragment found: TOS
MText fragment found: TOP OF STEEL
MText fragment found: LR
MText fragment found: LONG RADIUS
MText fragment found: TOG
MText fragment found: TOP  OF GRATING
MText fragment found: MDFT
MText fragment found: MINIMUM DRY FILM THICKNESS
MText fragment found: TWA
MText fragment found: THERMOWELL SCREWED
MText fragment found: MS
MText fragment found: MILD STEEL
MText fragment found: TWB
MText fragment found: THERMOWELL FLANGED
MText fragment found: N
MText fragment found: NORTH
MText fragment found: THK
MText fragment found: THICK
MText fragment found: No
MText fragment found: NUMBER
MText fragment found: TYP
MText fragment found: TYPICAL
MText fragment found: NOM
MText fragment found: NOMINAL
MText fragment found: WN
MText fragment found: WELD NECK
MText fragment found: NPS
MText fragment found: NOMINAL PIPE SIZE
MText fragment found: WT
MText fragment found: WALL THICKNESS
MText fragment found: CLASS
MText fragment found: 7.
MText fragment found: PIPE SUPPORT TYPES:
MText fragment found: PA
MText fragment found: FIXED ANCHOR
MText fragment found: PG
MText fragment found: GUIDE
MText fragment found: PC
MText fragment found: CONSTANT WEIGHT SUPPORT
MText fragment found: PS
MText fragment found: SLIDE
MText fragment found: 8.
MText fragment found: WHERE APPLICABLE DIMENSIONS SHOWN ON LONG SECTIONS ARE 
PLAN LENGTHS.
MText fragment found: 9.
MText fragment found: ALL GASKETS ARE 3.2mm THICK (COMPRESSED) UNLESS NOTED 
OTHERWISE.
MText fragment found: 10.
MText fragment found: ALL FITTING TO FITTING DIMENSIONS INCLUDE 3mm WELD GAPS.
MText fragment found: 11.
MText fragment found: CONTOURS REFLECT EXISTING GROUND LEVELS. WHERE APPLICABLE 
REFER LONG SECTION  FOR DESIGN
MText fragment found: GROUND LEVEL. CONFIRM LEVELS ON SITE.
MText fragment found: 12.
MText fragment found: INTERSECTION POINTS (IP's) SHALL BE PEGGED OUT AND 
VERIFIED BY COMPANY BEFORE SUPPORT OR
MText fragment found: PIPING INSTALLATION CAN COMMENCE.
MText fragment found: 13.
MText fragment found: MAXIMUM MISALIGNMENT OF ANY SUPPORT FROM A STRAIGHT LINE 
BETWEEN I.P.'s HORIZONTAL  ±10mm
MText fragment found: VERTICAL      ±3mm
MText fragment found: 14.
MText fragment found: INSULATION SHALL BE IN ACCORDANCE WITH THE FOLLOWING 
SPECIFICATION AND DRAWINGS:
MText fragment found: SPECIFICATION
MText fragment found: SK-M-SP-0036
MText fragment found: DRAWINGS
MText fragment found: SK-M-DR-0037, 0038, 0039
MText fragment found: 15.
MText fragment found: CONSTANT WEIGHT SUPPORT TO BE INSTALLED HORIZONTAL IN THE 
COLD POSITION (BOTH  PIPING AND
MText fragment found: WELL) UNLESS NOTED OTHERWISE.
MText fragment found: 16.
MText fragment found: CHANGES IN DIRECTION OR SLOPE TO BE FULL OR TRIMMED 
ELBOWS UNLESS SINGLE OR DOUBLE  MITER
MText fragment found: BENDS ARE SPECIFIED. FOR NITRE BEND DETAILS SEE DRAWING 
LISTED IN NOTE 1 ABOVE.
MText fragment found: 17.
MText fragment found: CONTRACTOR SHALL SUBMIT CONSTRUCTION PLAN AND METHODOLOGY 
FOR EACH AREA  (WELL PAD, CROSS
MText fragment found: COUNTRY ROUTE, TIE-IN, ETC.) TO COMPANY FOR REVIEW PRIOR 
TO  COMMENCING WORK.
MText fragment found: 18.
MText fragment found: CONTRACTOR SHALL SUBMIT HYDROTEST PLAN AND METHODOLOGY 
FOR EACH AREA TO  COMPANY FOR
MText fragment found: REVIEW PRIOR TO TESTING.

Selecting the resultant objects, we can see that – while we now have two – they are still MText:

If we use EXP on these two objects – selecting the same options as before – we finally see the MText decomposed into DBText objects (there’s no need to show the command-line results again – it’ll be the same as last time, with the minor difference of us selecting two objects instead of one). I’ve only selected the text in the first column – if we select all 133 objects in both columns, AutoCAD won’t show the grip markers, which makes it less clear they are now all separate objects:

Thanks for the interesting suggestion, Mike! :-)

Posted at 11:19 AM | Permalink | Comments (8)

February 16, 2011

Exploding AutoCAD objects using .NET

Time to go back to basics. I realised recently – on receiving this comment – that I hadn’t specifically covered the nature of Entity.Explode() in a post (even if it’s been used in a few of them, over the years).

Entity.Explode() is one of those tricky methods: it’s actually a faux-ami with the AutoCAD command of the same name, in a very similar way to Database.Purge(). The way in which Explode() and Purge() differ from their “equivalent” commands is that they’re non-destructive: they don’t actually result in a change to the AutoCAD drawing database. Explode() populates a DBObjectCollection with the results of the explode operation, and it’s then up to the caller of the function to add them to the appropriate location (typically the current – i.e. model- or paper- – space). Purge() checks a list of objects for ones that can safely be erased, and then it’s up to the caller of the function to do so.

So there is some occasional – and understandable – confusion around Explode() or Purge() not working as expected.

Here’s a simple approach to mimicking the behaviour of the EXPLODE command programmatically: after calling Entity.Explode() on each selected entity, we optionally erase the original entities and add the results of the Explode() to the drawing.

There’s a lot this code doesn’t do – such as check for entities that did not actually generate any exploded results (and so probably shouldn’t be erased) or output some feedback on what is happening to the command-line – but the principle should be clear enough.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
 
namespace Explosion
{
  public class Commands
  {
    [CommandMethod("EXP", CommandFlags.UsePickSet)]
    public void ExplodeEntities()
    {
      Document doc =
          Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask user to select entities
 
      PromptSelectionOptions pso =
        new PromptSelectionOptions();
      pso.MessageForAdding = "\nSelect objects to explode: ";
      pso.AllowDuplicates = false;
      pso.AllowSubSelections = true;
      pso.RejectObjectsFromNonCurrentSpace = true;
      pso.RejectObjectsOnLockedLayers = false;
 
      PromptSelectionResult psr = ed.GetSelection(pso);
      if (psr.Status != PromptStatus.OK)
        return;
 
      // Check whether to erase the original(s)
 
      bool eraseOrig = false;
 
      if (psr.Value.Count > 0)
      {
        PromptKeywordOptions pko =
          new PromptKeywordOptions("\nErase original objects?");
        pko.AllowNone = true;
        pko.Keywords.Add("Yes");
        pko.Keywords.Add("No");
        pko.Keywords.Default = "No";
 
        PromptResult pkr = ed.GetKeywords(pko);
        if (pkr.Status != PromptStatus.OK)
          return;
 
        eraseOrig = (pkr.StringResult == "Yes");
      }
 
      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        // Collect our exploded objects in a single collection
 
        DBObjectCollection objs = new DBObjectCollection();
 
        // Loop through the selected objects
 
        foreach (SelectedObject so in psr.Value)
        {
          // Open one at a time
 
          Entity ent =
            (Entity)tr.GetObject(
              so.ObjectId,
              OpenMode.ForRead
            );
 
          // Explode the object into our collection
 
          ent.Explode(objs);
 
          // Erase the original, if requested
 
          if (eraseOrig)
          {
            ent.UpgradeOpen();
            ent.Erase();
          }
        }
 
        // Now open the current space in order to
        // add our resultant objects
 
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            db.CurrentSpaceId,
            OpenMode.ForWrite
          );
 
        // Add each one of them to the current space
        // and to the transaction
 
        foreach (DBObject obj in objs)
        {
          Entity ent = (Entity)obj;
          btr.AppendEntity(ent);
          tr.AddNewlyCreatedDBObject(ent, true);
        }
 
        // And then we commit
 
        tr.Commit();
      }
    }
  }
} 

The results of calling the EXP command should be obvious enough – and do not result in anything very visually stimulating – so I’ll finish the post here.

Posted at 06:22 AM in AutoCAD, AutoCAD .NET, Blocks, Drawing structure | Permalink | Comments (13)

February 14, 2011

Creating the smallest possible sphere around 3D AutoCAD geometry using .NET

Given the last few posts – where we gathered 2D points, created a minimal circle around them, and then gathered 3D points – the topic of this post shouldn’t come as much of a surprise. :-)

As suggested, the changes needed to support 3D in the algorithm we used to solve the smallest circle problem were trivial: we had to adjust the function protocol to pass in a list of 3D points and the implementation to deal with the Z coordinates provided. Looking at the code again, I did consider adjusting it to pass in a Point3dCollection rather than a List<Point3d> (I has chosen to use a generic list when implementing the original recursive algorithm and had just kept it with the newer iterative one), but then decided to leave that particular aspect alone.

Here’s the updated C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using DbSurface =
  Autodesk.AutoCAD.DatabaseServices.Surface;
using DbNurbSurface =
  Autodesk.AutoCAD.DatabaseServices.NurbSurface;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Collections.Generic;
using System;
 
namespace MinimumEnclosingSphere
{
  public class Commands
  {
    [CommandMethod("MES", CommandFlags.UsePickSet)]
    public void MinimumEnclosingSphere()
    {
      Document doc =
          Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask user to select entities
 
      PromptSelectionOptions pso =
        new PromptSelectionOptions();
      pso.MessageForAdding = "\nSelect objects to enclose: ";
      pso.AllowDuplicates = false;
      pso.AllowSubSelections = true;
      pso.RejectObjectsFromNonCurrentSpace = true;
      pso.RejectObjectsOnLockedLayers = false;
 
      PromptSelectionResult psr = ed.GetSelection(pso);
      if (psr.Status != PromptStatus.OK)
        return;
 
      bool oneSpherePerEnt = false;
 
      if (psr.Value.Count > 1)
      {
        PromptKeywordOptions pko =
          new PromptKeywordOptions(
            "\nMultiple objects selected: create " +
            "individual spheres around each one?"
          );
        pko.AllowNone = true;
        pko.Keywords.Add("Yes");
        pko.Keywords.Add("No");
        pko.Keywords.Default = "No";
 
        PromptResult pkr = ed.GetKeywords(pko);
        if (pkr.Status != PromptStatus.OK)
          return;
 
        oneSpherePerEnt = (pkr.StringResult == "Yes");
      }
 
      // There may be a SysVar defining the buffer
      // to add to our radius
 
      double buffer = 0.0;
      try
      {
        object bufvar =
          Application.GetSystemVariable(
            "ENCLOSINGCIRCLEBUFFER"
          );
        if (bufvar != null)
        {
          short bufval = (short)bufvar;
          buffer = bufval / 100.0;
        }
      }
      catch
      {
        object bufvar =
          Application.GetSystemVariable("USERI1");
        if (bufvar != null)
        {
          short bufval = (short)bufvar;
          buffer = bufval / 100.0;
        }
      }
 
      // Collect points on the component entities
 
      Point3dCollection pts = new Point3dCollection();
 
      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            db.CurrentSpaceId,
            OpenMode.ForWrite
          );
 
        for (int i = 0; i < psr.Value.Count; i++)
        {
          Entity ent =
            (Entity)tr.GetObject(
              psr.Value[i].ObjectId,
              OpenMode.ForRead
            );
 
          // Collect the points for each selected entity
 
          CollectPoints(tr, ent, pts);
 
          // Create a sphere for each entity (if so chosen) or
          // just once after collecting all the points
 
          if (oneSpherePerEnt || i == psr.Value.Count - 1)
          {
            try
            {
              Solid3d sol = SphereFromPoints(pts, buffer);
              btr.AppendEntity(sol);
              tr.AddNewlyCreatedDBObject(sol, true);
            }
            catch
            {
              ed.WriteMessage(
                "\nUnable to calculate enclosing sphere."
              );
            }
 
            pts.Clear();
          }
        }
 
        tr.Commit();
      }
    }
 
    private Solid3d SphereFromPoints(
      Point3dCollection pts, double buffer
    )
    {
      // Copy the points across
 
      List<Point3d> pts3d = new List<Point3d>(pts.Count);
      for (int i = 0; i < pts.Count; i++)
      {
        pts3d.Add(pts[i]);
      }
 
      // Assuming we have some points in our list...
 
      if (pts.Count > 0)
      {
        // We need the center and radius of our sphere
 
        Point3d center;
        double radius = 0;
 
        // Use our fast approximation algorithm to
        // calculate the center and radius of our
        // sphere to within 1% (calling the function
        // with 100 iterations gives 10%, calling it
        // with 10K gives 1%)
 
        BadoiuClarksonIteration(
          pts3d, 10000, out center, out radius
        );
 
        // Create the sphere and return it
 
        Solid3d sol = new Solid3d();
        sol.CreateSphere(radius * (1.0 + buffer));
        sol.TransformBy(
          Matrix3d.Displacement(center - Point3d.Origin)
        );
        return sol;
      }
      return null;
    }
 
    private void CollectPoints(
      Transaction tr, Entity ent, Point3dCollection pts
    )
    {
      // We'll start by checking a block reference for
      // attributes, getting their bounds and adding
      // them to the point list. We'll still explode
      // the BlockReference later, to gather points
      // from other geometry, it's just that approach
      // doesn't work for attributes (we only get the
      // AttributeDefinitions, which don't have bounds)
 
      BlockReference br = ent as BlockReference;
      if (br != null)
      {
        foreach (ObjectId arId in br.AttributeCollection)
        {
          DBObject obj = tr.GetObject(arId, OpenMode.ForRead);
          if (obj is AttributeReference)
          {
            AttributeReference ar = (AttributeReference)obj;
            ExtractBounds(ar, pts);
          }
        }
      }
 
      // For surfaces we'll do something similar: we'll
      // collect points across its surface (by first getting
      // NURBS surfaces for the surface) and will still
      // explode the surface later to get points from the
      // curves
 
      DbSurface sur = ent as DbSurface;
      if (sur != null)
      {
        DbNurbSurface[] nurbs = sur.ConvertToNurbSurface();
        foreach (DbNurbSurface nurb in nurbs)
        {
          // Calculate the parameter increments in u and v
 
          double ustart = nurb.UKnots.StartParameter,
                uend = nurb.UKnots.EndParameter,
                uinc = (uend - ustart) / nurb.UKnots.Count,
                vstart = nurb.VKnots.StartParameter,
                vend = nurb.VKnots.EndParameter,
                vinc = (vend - vstart) / nurb.VKnots.Count;
 
          // Pick up points across the surface
 
          for (double u = ustart; u <= uend; u += uinc)
          {
            for (double v = vstart; v <= vend; v += vinc)
            {
              pts.Add(nurb.Evaluate(u, v));
            }
          }
        }
      }
 
      // For 3D solids we'll fire a number of rays from the
      // centroid in random directions in order to get a
      // sampling of points on the outside
 
      Solid3d sol = ent as Solid3d;
      if (sol != null)
      {
        for (int i = 0; i < 500; i++)
        {
          Solid3dMassProperties mp = sol.MassProperties;
 
          using (Plane pl = new Plane())
          {
            pl.Set(mp.Centroid, randomVector3d());
            using (Region reg = sol.GetSection(pl))
            {
              using (Ray ray = new Ray())
              {
                ray.BasePoint = mp.Centroid;
                ray.UnitDir = randomVectorOnPlane(pl);
 
                reg.IntersectWith(
                  ray, Intersect.OnBothOperands, pts,
                  IntPtr.Zero, IntPtr.Zero
                );
              }
            }
          }
        }
      }
 
      // Now we start the terminal cases - for basic objects -
      // before we recurse for more complex objects (including
      // the ones we've already collected points for above).
 
      // If we have a curve - other than a polyline, which
      // we will want to explode - we'll get points along
      // its length
 
      Curve cur = ent as Curve;
      if (cur != null &&
          !(cur is Polyline ||
            cur is Polyline2d ||
            cur is Polyline3d))
      {
        // Two points are enough for a line, we'll go with
        // a higher number for other curves
 
        int segs = (ent is Line ? 2 : 20);
 
        double param = cur.EndParam - cur.StartParam;
        for (int i = 0; i < segs; i++)
        {
          try
          {
            Point3d pt =
              cur.GetPointAtParameter(
                cur.StartParam + (i * param / (segs - 1))
              );
            pts.Add(pt);
          }
          catch { }
        }
      }
      else if (ent is DBPoint)
      {
        // Points are easy
 
        pts.Add(((DBPoint)ent).Position);
      }
      else if (ent is DBText)
      {
        // For DBText we use the same approach as
        // for AttributeReferences
 
        ExtractBounds((DBText)ent, pts);
      }
      else if (ent is MText)
      {
        // MText is also easy - you get all four corners
        // returned by a function. That said, the points
        // are of the MText's box, so may well be different
        // from the bounds of the actual contents
 
        MText txt = (MText)ent;
        Point3dCollection pts2 = txt.GetBoundingPoints();
        foreach (Point3d pt in pts2)
        {
          pts.Add(pt);
        }
      }
      else if (ent is Face)
      {
        Face f = (Face)ent;
        try
        {
          for (short i = 0; i < 4; i++)
          {
            pts.Add(f.GetVertexAt(i));
          }
        }
        catch { }
      }
      else if (ent is Solid)
      {
        Solid s = (Solid)ent;
        try
        {
          for (short i = 0; i < 4; i++)
          {
            pts.Add(s.GetPointAt(i));
          }
        }
        catch { }
      }
      else
      {
        // Here's where we attempt to explode other types
        // of object
 
        DBObjectCollection oc = new DBObjectCollection();
        try
        {
          ent.Explode(oc);
          if (oc.Count > 0)
          {
            foreach (DBObject obj in oc)
            {
              Entity ent2 = obj as Entity;
              if (ent2 != null && ent2.Visible)
              {
                CollectPoints(tr, ent2, pts);
              }
              obj.Dispose();
            }
          }
        }
        catch { }
      }
    }
 
    // Return a random 3D vector on a plane
 
    private Vector3d randomVectorOnPlane(Plane pl)
    {
      // Create our random number generator
 
      Random ran = new Random();
 
      // First we get the absolute value
      // of our x, y and z coordinates
 
      double absx = ran.NextDouble();
      double absy = ran.NextDouble();
 
      // Then we negate them, half of the time
 
      double x = (ran.NextDouble() < 0.5 ? -absx : absx);
      double y = (ran.NextDouble() < 0.5 ? -absy : absy);
 
      Vector2d v2 = new Vector2d(x,y);
      return new Vector3d(pl, v2);
    }
 
    // Return a random 3D vector
 
    private Vector3d randomVector3d()
    {
      // Create our random number generator
 
      Random ran = new Random();
 
      // First we get the absolute value
      // of our x, y and z coordinates
 
      double absx = ran.NextDouble();
      double absy = ran.NextDouble();
      double absz = ran.NextDouble();
 
      // Then we negate them, half of the time
 
      double x = (ran.NextDouble() < 0.5 ? -absx : absx);
      double y = (ran.NextDouble() < 0.5 ? -absy : absy);
      double z = (ran.NextDouble() < 0.5 ? -absz : absz);
 
      return new Vector3d(x, y, z);
    }
 
    private void ExtractBounds(
      DBText txt, Point3dCollection pts
    )
    {
      // We have a special approach for DBText and
      // AttributeReference objects, as we want to get
      // all four corners of the bounding box, even
      // when the text or the containing block reference
      // is rotated
 
      if (txt.Bounds.HasValue && txt.Visible)
      {
        // Create a straight version of the text object
        // and copy across all the relevant properties
        // (stopped copying AlignmentPoint, as it would
        // sometimes cause an eNotApplicable error)
 
        // We'll create the text at the WCS origin
        // with no rotation, so it's easier to use its
        // extents
 
        DBText txt2 = new DBText();
        txt2.Normal = Vector3d.ZAxis;
        txt2.Position = Point3d.Origin;
 
        // Other properties are copied from the original
 
        txt2.TextString = txt.TextString;
        txt2.TextStyleId = txt.TextStyleId;
        txt2.LineWeight = txt.LineWeight;
        txt2.Thickness = txt2.Thickness;
        txt2.HorizontalMode = txt.HorizontalMode;
        txt2.VerticalMode = txt.VerticalMode;
        txt2.WidthFactor = txt.WidthFactor;
        txt2.Height = txt.Height;
        txt2.IsMirroredInX = txt2.IsMirroredInX;
        txt2.IsMirroredInY = txt2.IsMirroredInY;
        txt2.Oblique = txt.Oblique;
 
        // Get its bounds if it has them defined
        // (which it should, as the original did)
 
        if (txt2.Bounds.HasValue)
        {
          Point3d maxPt = txt2.Bounds.Value.MaxPoint;
 
          // Place all four corners of the bounding box
          // in an array
 
          Point2d[] bounds =
            new Point2d[] {
              Point2d.Origin,
              new Point2d(0.0, maxPt.Y),
              new Point2d(maxPt.X, maxPt.Y),
              new Point2d(maxPt.X, 0.0)
            };
 
          // We're going to get each point's WCS coordinates
          // using the plane the text is on
 
          Plane pl = new Plane(txt.Position, txt.Normal);
 
          // Rotate each point and add its WCS location to the
          // collection
 
          foreach (Point2d pt in bounds)
          {
            pts.Add(
              pl.EvaluatePoint(
                pt.RotateBy(txt.Rotation, Point2d.Origin)
              )
            );
          }
        }
      }
    }
 
    // Algorithm courtesy (and copyright of) Frank Nielsen
    // http://blog.informationgeometry.org/article.php?id=164
 
    public void BadoiuClarksonIteration(
      List<Point3d> set, int iter,
      out Point3d cen, out double rad
    )
    {
      // Choose any point of the set as the initial
      // circumcenter
 
      cen = set[0];
      rad = 0;
 
      for (int i = 0; i < iter; i++)
      {
        int winner = 0;
        double distmax = (cen - set[0]).Length;
 
        // Maximum distance point
 
        for (int j = 1; j < set.Count; j++)
        {
          double dist = (cen - set[j]).Length;
          if (dist > distmax)
          {
            winner = j;
            distmax = dist;
          }
        }
        rad = distmax;
 
        // Update
 
        cen =
          new Point3d(
            cen.X + (1.0 / (i + 1.0)) * (set[winner].X - cen.X),
            cen.Y + (1.0 / (i + 1.0)) * (set[winner].Y - cen.Y),
            cen.Z + (1.0 / (i + 1.0)) * (set[winner].Z - cen.Z)
          );
      }
    }
  }
}
 

We’ll run the new MES (Minimal Enclosing Sphere) command against the 3D geometry we saw in the last post…

… after setting ENCLOSINGCIRCLEBUFFER (we haven’t bothered implementing a separate ENCLOSINGSPHEREBUFFER, but we very easily could, if needed) to zero.

Command: ENCLOSINGCIRCLEBUFFER
Enter new value for ENCLOSINGCIRCLEBUFFER <3>: 0
Command: MES
Select objects to enclose: ALL
9 found
Select objects to enclose:
Multiple objects selected: create individual spheres around each one? [Yes/No] <No>: Y

Here are the results:

Which are perhaps more visible with the x-ray visual style applied:

Such operations certainly have the potential to be time-consuming… the code should probably be adjusted to show a progress meter or – at the very least – check HostApplicationServices.Current.UserBreak() from time to time. Something I’d certainly do myself, if preparing this code for production use, but for now left as an exercise for the reader.

Posted at 06:03 AM in AutoCAD, AutoCAD .NET, Solid modeling | Permalink | Comments (0)

February 11, 2011

Gathering points defining 3D AutoCAD geometry using .NET

After revealing the purpose for collecting points from 2D geometry in the last post, this post extends the 2D collection code to work with additional 3D objects. I don’t know whether it’s exhaustive or not – I’ve added more specific support for Solid3d and Surface objects – but I have no doubt people will let me know if I’ve missed anything, over time.

The good news is that the previous approach of exploding complex entities and processing their components means that many types of standard solid – such as boxes, cones and pyramids – will get adequately captured using this approach, as they have faces that comfortably get decomposed down to primitive objects that are handled by the existing code. The same is true of SubDMesh objects and even – to some degree – surfaces (although for these we are likely to only get the defining curves, rather than points along the surface itself).

To get more information from Surface objects was reasonably easy: the code creates NURBS surfaces from the surface and processes each of these by getting points inside the u and v parameter space. In addition to any enclosing curves that get processed as the Surface is exploded, of course. There may be a more straightforward way, but this appears to work, at least.

For Solid3ds it was a little more complex. I took some F# code from this previous post as a basis, to fire rays in random directions from the centroid of the solid and pick up the points at which the objects intersect. It’s not a guaranteed way to get points defining the solid, but with a couple of thousand points being generated by a thousand intersection operations, it should be representative enough. And that’s once again in addition to any curves or faces extracted from the solid as it’s exploded.

It should be said that none of these collection operations have been optimized for performance – this is mostly about getting lots of points to help generate an enclosing sphere, later on. A simple optimization would be to not perform the ray-firing technique on solids that we know are handled well by the explode approach (although that may require the use of COM to get the solid type, if memory serves me correctly). Anyway – this isn’t a definitive approach, this is more about sharing some code that I hope will prove useful to people who wish to take it further.

Here’s the updated C# code – the main changes are at the beginning of the CollectPoints() function, where I’ve added the handling of Solid3d and Surface objects. The function;s protocol has also be changed, slightly – rather than returning a collection of points from each call, we just pass the collection around and populate it directly. Not a big change, but it saved a couple of foreach loops that simply copy points from one place to another. Oh, and I was also forgetting to call Dispose() on the results of the Explode() operation, which only became apparent as a problem when dealing with larger models.

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using DbSurface =
  Autodesk.AutoCAD.DatabaseServices.Surface;
using DbNurbSurface =
  Autodesk.AutoCAD.DatabaseServices.NurbSurface;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Collections.Generic;
using System;
 
namespace PointGathering
{
  public class Commands
  {
    [CommandMethod("GP", CommandFlags.UsePickSet)]
    public void GatherPoints()
    {
      Document doc =
          Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask user to select entities
 
      PromptSelectionOptions pso =
        new PromptSelectionOptions();
      pso.MessageForAdding = "\nSelect entities to enclose: ";
      pso.AllowDuplicates = false;
      pso.AllowSubSelections = true;
      pso.RejectObjectsFromNonCurrentSpace = true;
      pso.RejectObjectsOnLockedLayers = false;
 
      PromptSelectionResult psr = ed.GetSelection(pso);
      if (psr.Status != PromptStatus.OK)
        return;
 
      // Collect points on the component entities
 
      Point3dCollection pts = new Point3dCollection();
 
      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            db.CurrentSpaceId,
            OpenMode.ForWrite
          );
 
        foreach (SelectedObject so in psr.Value)
        {
          Entity ent =
            (Entity)tr.GetObject(
              so.ObjectId,
              OpenMode.ForRead
            );
 
          // Collect the points for each selected entity
 
          Point3dCollection entPts = new Point3dCollection();
          CollectPoints(tr, ent, entPts);
 
          // Add a physical DBPoint at each Point3d
 
          foreach(Point3d pt in entPts)
          {
            DBPoint dbp = new DBPoint(pt);
            btr.AppendEntity(dbp);
            tr.AddNewlyCreatedDBObject(dbp, true);
          }
        }
        tr.Commit();
      }
    }
 
    private void CollectPoints(
      Transaction tr, Entity ent, Point3dCollection pts
    )
    {
      // We'll start by checking a block reference for
      // attributes, getting their bounds and adding
      // them to the point list. We'll still explode
      // the BlockReference later, to gather points
      // from other geometry, it's just that approach
      // doesn't work for attributes (we only get the
      // AttributeDefinitions, which don't have bounds)
 
      BlockReference br = ent as BlockReference;
      if (br != null)
      {
        foreach (ObjectId arId in br.AttributeCollection)
        {
          DBObject obj = tr.GetObject(arId, OpenMode.ForRead);
          if (obj is AttributeReference)
          {
            AttributeReference ar = (AttributeReference)obj;
            ExtractBounds(ar, pts);
          }
        }
      }
 
      // For surfaces we'll do something similar: we'll
      // collect points across its surface (by first getting
      // NURBS surfaces for the surface) and will still
      // explode the surface later to get points from the
      // curves
 
      DbSurface sur = ent as DbSurface;
      if (sur != null)
      {
        DbNurbSurface[] nurbs = sur.ConvertToNurbSurface();
        foreach (DbNurbSurface nurb in nurbs)
        {
          // Calculate the parameter increments in u and v
 
          double ustart = nurb.UKnots.StartParameter,
                uend = nurb.UKnots.EndParameter,
                uinc = (uend - ustart) / nurb.UKnots.Count,
                vstart = nurb.VKnots.StartParameter,
                vend = nurb.VKnots.EndParameter,
                vinc = (vend - vstart) / nurb.VKnots.Count;
 
          // Pick up points across the surface
 
          for (double u = ustart; u <= uend; u += uinc)
          {
            for (double v = vstart; v <= vend; v += vinc)
            {
              pts.Add(nurb.Evaluate(u, v));
            }
          }
        }
      }
 
      // For 3D solids we'll fire a number of rays from the
      // centroid in random directions in order to get a
      // sampling of points on the outside
 
      Solid3d sol = ent as Solid3d;
      if (sol != null)
      {
        for (int i = 0; i < 500; i++)
        {
          Solid3dMassProperties mp = sol.MassProperties;
 
          using (Plane pl = new Plane())
          {
            pl.Set(mp.Centroid, randomVector3d());
            using (Region reg = sol.GetSection(pl))
            {
              using (Ray ray = new Ray())
              {
                ray.BasePoint = mp.Centroid;
                ray.UnitDir = randomVectorOnPlane(pl);
 
                reg.IntersectWith(
                  ray, Intersect.OnBothOperands, pts,
                  IntPtr.Zero, IntPtr.Zero
                );
              }
            }
          }
        }
      }
 
      // Now we start the terminal cases - for basic objects -
      // before we recurse for more complex objects (including
      // the ones we've already collected points for above).
 
      // If we have a curve - other than a polyline, which
      // we will want to explode - we'll get points along
      // its length
 
      Curve cur = ent as Curve;
      if (cur != null &&
          !(cur is Polyline ||
            cur is Polyline2d ||
            cur is Polyline3d))
      {
        // Two points are enough for a line, we'll go with
        // a higher number for other curves
 
        int segs = (ent is Line ? 2 : 20);
 
        double param = cur.EndParam - cur.StartParam;
        for (int i = 0; i < segs; i++)
        {
          try
          {
            Point3d pt =
              cur.GetPointAtParameter(
                cur.StartParam + (i * param / (segs - 1))
              );
            pts.Add(pt);
          }
          catch { }
        }
      }
      else if (ent is DBPoint)
      {
        // Points are easy
 
        pts.Add(((DBPoint)ent).Position);
      }
      else if (ent is DBText)
      {
        // For DBText we use the same approach as
        // for AttributeReferences
 
        ExtractBounds((DBText)ent, pts);
      }
      else if (ent is MText)
      {
        // MText is also easy - you get all four corners
        // returned by a function. That said, the points
        // are of the MText's box, so may well be different
        // from the bounds of the actual contents
 
        MText txt = (MText)ent;
        Point3dCollection pts2 = txt.GetBoundingPoints();
        foreach (Point3d pt in pts2)
        {
          pts.Add(pt);
        }
      }
      else if (ent is Face)
      {
        Face f = (Face)ent;
        try
        {
          for (short i = 0; i < 4; i++)
          {
            pts.Add(f.GetVertexAt(i));
          }
        }
        catch { }
      }
      else if (ent is Solid)
      {
        Solid s = (Solid)ent;
        try
        {
          for (short i = 0; i < 4; i++)
          {
            pts.Add(s.GetPointAt(i));
          }
        }
        catch { }
      }
      else
      {
        // Here's where we attempt to explode other types
        // of object
 
        DBObjectCollection oc = new DBObjectCollection();
        try
        {
          ent.Explode(oc);
          if (oc.Count > 0)
          {
            foreach (DBObject obj in oc)
            {
              Entity ent2 = obj as Entity;
              if (ent2 != null && ent2.Visible)
              {
                CollectPoints(tr, ent2, pts);
              }
              obj.Dispose();
            }
          }
        }
        catch { }
      }
    }
 
    // Return a random 3D vector on a plane
 
    private Vector3d randomVectorOnPlane(Plane pl)
    {
      // Create our random number generator
 
      Random ran = new Random();
 
      // First we get the absolute value
      // of our x, y and z coordinates
 
      double absx = ran.NextDouble();
      double absy = ran.NextDouble();
 
      // Then we negate them, half of the time
 
      double x = (ran.NextDouble() < 0.5 ? -absx : absx);
      double y = (ran.NextDouble() < 0.5 ? -absy : absy);
 
      Vector2d v2 = new Vector2d(x, y);
      return new Vector3d(pl, v2);
    }
 
    // Return a random 3D vector
 
    private Vector3d randomVector3d()
    {
      // Create our random number generator
 
      Random ran = new Random();
 
      // First we get the absolute value
      // of our x, y and z coordinates
 
      double absx = ran.NextDouble();
      double absy = ran.NextDouble();
      double absz = ran.NextDouble();
 
      // Then we negate them, half of the time
 
      double x = (ran.NextDouble() < 0.5 ? -absx : absx);
      double y = (ran.NextDouble() < 0.5 ? -absy : absy);
      double z = (ran.NextDouble() < 0.5 ? -absz : absz);
 
      return new Vector3d(x, y, z);
    }
 
    private void ExtractBounds(
      DBText txt, Point3dCollection pts
    )
    {
      // We have a special approach for DBText and
      // AttributeReference objects, as we want to get
      // all four corners of the bounding box, even
      // when the text or the containing block reference
      // is rotated
 
      if (txt.Bounds.HasValue && txt.Visible)
      {
        // Create a straight version of the text object
        // and copy across all the relevant properties
        // (stopped copying AlignmentPoint, as it would
        // sometimes cause an eNotApplicable error)
 
        // We'll create the text at the WCS origin
        // with no rotation, so it's easier to use its
        // extents
 
        DBText txt2 = new DBText();
        txt2.Normal = Vector3d.ZAxis;
        txt2.Position = Point3d.Origin;
 
        // Other properties are copied from the original
 
        txt2.TextString = txt.TextString;
        txt2.TextStyleId = txt.TextStyleId;
        txt2.LineWeight = txt.LineWeight;
        txt2.Thickness = txt2.Thickness;
        txt2.HorizontalMode = txt.HorizontalMode;
        txt2.VerticalMode = txt.VerticalMode;
        txt2.WidthFactor = txt.WidthFactor;
        txt2.Height = txt.Height;
        txt2.IsMirroredInX = txt2.IsMirroredInX;
        txt2.IsMirroredInY = txt2.IsMirroredInY;
        txt2.Oblique = txt.Oblique;
 
        // Get its bounds if it has them defined
        // (which it should, as the original did)
 
        if (txt2.Bounds.HasValue)
        {
          Point3d maxPt = txt2.Bounds.Value.MaxPoint;
 
          // Place all four corners of the bounding box
          // in an array
 
          Point2d[] bounds =
            new Point2d[] {
              Point2d.Origin,
              new Point2d(0.0, maxPt.Y),
              new Point2d(maxPt.X, maxPt.Y),
              new Point2d(maxPt.X, 0.0)
            };
 
          // We're going to get each point's WCS coordinates
          // using the plane the text is on
 
          Plane pl = new Plane(txt.Position, txt.Normal);
 
          // Rotate each point and add its WCS location to the
          // collection
 
          foreach (Point2d pt in bounds)
          {
            pts.Add(
              pl.EvaluatePoint(
                pt.RotateBy(txt.Rotation, Point2d.Origin)
              )
            );
          }
        }
      }
    }
  }
} 

Here’s the updated GP command in action with a selection of 3D geometry.

The basic geometry:

With our points:

And with PDMODE set to 2:

In the next post we’ll extend this code that little bit further to create an enclosing sphere, as we did for enclosing circles last time.

Posted at 11:42 AM in AutoCAD, AutoCAD .NET, Geometry, Solid modeling | Permalink | Comments (12)

February 09, 2011

Creating the smallest possible circle around 2D AutoCAD geometry using .NET

Now it’s time to shed some light on the reason for the code in the last post. I wrote it to help address a question that came in from Elson Brown via our Plugin of the Month feedback alias:

I have a request for an app that will draw the smallest circle around a polyline object. Pick the polyline and the app draws the smallest possible circle around the shape.

It turns out this is a well-known problem (and thanks to Stephen Preston for pointing me in this direction), commonly known as the minimal enclosing circle or smallest circle problem.

This struck me as a fun problem to solve inside AutoCAD (and probably some of our other products, too), so I started looking at the (typically C++) code projects linked to from the Wikipedia page. Having taken a deep breath, I started looking at Bernd Gärtner's smallest enclosing ball of points code, to see whether I could make sense of it. Sadly it was a little too complex for me to bring across to C#, but it started me in a good direction.

I considered – briefly – the idea of just using an open source library, whether CGAL (for computational geometry) or OpenCV (for computer vision), both of which provide functions that solve this problem. It just seemed overkill: I don’t currently need any of the other functions in either of these very impressive libraries, and using them would most probably add complexity when supporting 32- vs. 64-bit platforms, etc.

So back to implementing something myself (or rather porting something from someone else :-). Searching on “miniball”, I came across this C++ implementation from Frank Nielsen, Professor of Computer Science at the LIX (le Laboratoire d’Informatique de l'École Polytechnique) in France and Senior Researcher at Sony CSL FRL (the Fundamental Research Laboratory of Sony Computer Science Laboratories). I managed to implement this in C# – having contacted Frank to get his permission to do so – and it worked well: the only problem was with the fact it’s a recursive algorithm, and calling it with lots of points (extracted from the selected AutoCAD geometry using the technique shown in the last post) leads to a stack overflow, a common phenomenon with deeply recursive code. I did some work to reduce the set of points extracted from the geometry – using LINQ to filter out points near the centre of the circle, for instance – but the approach could still have caused problems when a certain threshold was exceeded. It should be noted that our use of recursion in the last post – where we recurse for each level of containment, whether for blocks or “complex” entities such as polylines – results in very few recursive calls (I’d be surprised if there were 10 additional items in the call stack because of the recursion), whereas the miniball algorithm was recursing for each point (as far as I could tell).

Thankfully Frank came to my rescue, and suggested another, iterative algorithm, based on work by Bădoiu and Clarkson, to approximate a solution to this problem. Thankfully there was also a C++ implementation of the algorithm available, which helped me a lot (working from the mathematical description of an algorithm makes my head hurt – I’m just not used to thinking like that).

Both of these implementations come from the material for one of Frank’s books entitled Visual Computing: Geometry, Graphics, and Vision. Given what I’ve seen so far from this book, I’m certainly going to pick up a copy of it (and hopefully some of you will, too, to repay Frank for his kind contributions to this post :-).

The iterative algorithm worked a treat. If you iterate 10,000 times (which happens quickly enough) there is a 1% margin of error, which is altogether acceptable (especially as the code allows you to add a buffer percentage to the calculated radius, so that we’re not quite touching the enclosed geometry).

It’s worth noting that the algorithm can work on n-dimensional points, so I’ll probably be using it to create a sphere, at some point (I don’t think I’ll personally be needing to solve the problem for any more than three dimensions, though :-).

Here’s the C# code that builds on the code shown in the last post:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Collections.Generic;
 
namespace MinimumEnclosingCircle
{
  public class Commands
  {
    [CommandMethod("MEC", CommandFlags.UsePickSet)]
    public void MinimumEnclosingCircle()
    {
      Document doc =
          Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask user to select entities
 
      PromptSelectionOptions pso =
        new PromptSelectionOptions();
      pso.MessageForAdding = "\nSelect objects to enclose: ";
      pso.AllowDuplicates = false;
      pso.AllowSubSelections = true;
      pso.RejectObjectsFromNonCurrentSpace = true;
      pso.RejectObjectsOnLockedLayers = false;
 
      PromptSelectionResult psr = ed.GetSelection(pso);
      if (psr.Status != PromptStatus.OK)
        return;
 
      bool oneCircPerEnt = false;
 
      if (psr.Value.Count > 1)
      {
        PromptKeywordOptions pko =
          new PromptKeywordOptions(
            "\nMultiple objects selected: create " +
            "individual circles around each one?"
          );
        pko.AllowNone = true;
        pko.Keywords.Add("Yes");
        pko.Keywords.Add("No");
        pko.Keywords.Default = "No";
 
        PromptResult pkr = ed.GetKeywords(pko);
        if (pkr.Status != PromptStatus.OK)
          return;
 
        oneCircPerEnt = (pkr.StringResult == "Yes");
      }
 
      // There may be a SysVar defining the buffer
      // to add to our radius
 
      double buffer = 0.0;
      try
      {
        object bufvar =
          Application.GetSystemVariable(
            "ENCLOSINGCIRCLEBUFFER"
          );
        if (bufvar != null)
        {
          short bufval = (short)bufvar;
          buffer = bufval / 100.0;
        }
      }
      catch
      {
        object bufvar =
          Application.GetSystemVariable("USERI1");
        if (bufvar != null)
        {
          short bufval = (short)bufvar;
          buffer = bufval / 100.0;
        }
      }
 
      // Get the current UCS
 
      CoordinateSystem3d ucs =
        ed.CurrentUserCoordinateSystem.CoordinateSystem3d;
 
      // Collect points on the component entities
 
      Point3dCollection pts = new Point3dCollection();
 
      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            db.CurrentSpaceId,
            OpenMode.ForWrite
          );
 
        for (int i = 0; i < psr.Value.Count; i++)
        {
          Entity ent =
            (Entity)tr.GetObject(
              psr.Value[i].ObjectId,
              OpenMode.ForRead
            );
 
          // Collect the points for each selected entity
 
          Point3dCollection entPts = CollectPoints(tr, ent);
          foreach (Point3d pt in entPts)
          {
            /*
            * Create a DBPoint, for testing purposes
            * 
            DBPoint dbp = new DBPoint(pt);
            btr.AppendEntity(dbp);
            tr.AddNewlyCreatedDBObject(dbp, true);
            */
 
            pts.Add(pt);
          }
 
          // Create a circle for each entity (if so chosen) or
          // just once after collecting all the points
 
          if (oneCircPerEnt || i == psr.Value.Count - 1)
          {
            try
            {
              Circle cir =
                CircleFromPoints(pts, ucs, buffer);
              btr.AppendEntity(cir);
              tr.AddNewlyCreatedDBObject(cir, true);
            }
            catch
            {
              ed.WriteMessage(
                "\nUnable to calculate enclosing circle."
              );
            }
 
            pts.Clear();
          }
        }
 
        tr.Commit();
      }
    }
 
    private Point3dCollection CollectPoints(
      Transaction tr, Entity ent
    )
    {
      // The collection of points to populate and return
 
      Point3dCollection pts = new Point3dCollection();
 
      // We'll start by checking a block reference for
      // attributes, getting their bounds and adding
      // them to the point list. We'll still explode
      // the BlockReference later, to gather points
      // from other geometry, it's just that approach
      // doesn't work for attributes (we only get the
      // AttributeDefinitions, which don't have bounds)
 
      BlockReference br = ent as BlockReference;
      if (br != null)
      {
        foreach (ObjectId arId in br.AttributeCollection)
        {
          DBObject obj = tr.GetObject(arId, OpenMode.ForRead);
          if (obj is AttributeReference)
          {
            AttributeReference ar = (AttributeReference)obj;
            ExtractBounds(ar, pts);
          }
        }
      }
 
      // If we have a curve - other than a polyline, which
      // we will want to explode - we'll get points along
      // its length
 
      Curve cur = ent as Curve;
      if (cur != null &&
          !(cur is Polyline ||
            cur is Polyline2d ||
            cur is Polyline3d))
      {
        // Two points are enough for a line, we'll go with
        // a higher number for other curves
 
        int segs = (ent is Line ? 2 : 20);
 
        double param = cur.EndParam - cur.StartParam;
        for (int i = 0; i < segs; i++)
        {
          try
          {
            Point3d pt =
              cur.GetPointAtParameter(
                cur.StartParam + (i * param / (segs - 1))
              );
            pts.Add(pt);
          }
          catch { }
        }
      }
      else if (ent is DBPoint)
      {
        // Points are easy
 
        pts.Add(((DBPoint)ent).Position);
      }
      else if (ent is DBText)
      {
        // For DBText we use the same approach as
        // for AttributeReferences
 
        ExtractBounds((DBText)ent, pts);
      }
      else if (ent is MText)
      {
        // MText is also easy - you get all four corners
        // returned by a function. That said, the points
        // are of the MText's box, so may well be different
        // from the bounds of the actual contents
 
        MText txt = (MText)ent;
        Point3dCollection pts2 = txt.GetBoundingPoints();
        foreach (Point3d pt in pts2)
        {
          pts.Add(pt);
        }
      }
      else if (ent is Face)
      {
        Face f = (Face)ent;
        try
        {
          for (short i = 0; i < 4; i++)
          {
            pts.Add(f.GetVertexAt(i));
          }
        }
        catch { }
      }
      else if (ent is Solid)
      {
        Solid sol = (Solid)ent;
        try
        {
          for (short i = 0; i < 4; i++)
          {
            pts.Add(sol.GetPointAt(i));
          }
        }
        catch { }
      }
      else
      {
        // Here's where we attempt to explode other types
        // of object
 
        DBObjectCollection oc = new DBObjectCollection();
        try
        {
          ent.Explode(oc);
          if (oc.Count > 0)
          {
            foreach (DBObject obj in oc)
            {
              Entity ent2 = obj as Entity;
              if (ent2 != null && ent2.Visible)
              {
                foreach (Point3d pt in CollectPoints(tr, ent2))
                {
                  pts.Add(pt);
                }
              }
              obj.Dispose();
            }
          }
        }
        catch { }
      }
      return pts;
    }
 
    private void ExtractBounds(
      DBText txt, Point3dCollection pts
    )
    {
      // We have a special approach for DBText and
      // AttributeReference objects, as we want to get
      // all four corners of the bounding box, even
      // when the text or the containing block reference
      // is rotated
 
      if (txt.Bounds.HasValue && txt.Visible)
      {
        // Create a straight version of the text object
        // and copy across all the relevant properties
        // (stopped copying AlignmentPoint, as it would
        // sometimes cause an eNotApplicable error)
 
        // We'll create the text at the WCS origin
        // with no rotation, so it's easier to use its
        // extents
 
        DBText txt2 = new DBText();
        txt2.Normal = Vector3d.ZAxis;
        txt2.Position = Point3d.Origin;
 
        // Other properties are copied from the original
 
        txt2.TextString = txt.TextString;
        txt2.TextStyleId = txt.TextStyleId;
        txt2.LineWeight = txt.LineWeight;
        txt2.Thickness = txt2.Thickness;
        txt2.HorizontalMode = txt.HorizontalMode;
        txt2.VerticalMode = txt.VerticalMode;
        txt2.WidthFactor = txt.WidthFactor;
        txt2.Height = txt.Height;
        txt2.IsMirroredInX = txt2.IsMirroredInX;
        txt2.IsMirroredInY = txt2.IsMirroredInY;
        txt2.Oblique = txt.Oblique;
 
        // Get its bounds if it has them defined
        // (which it should, as the original did)
 
        if (txt2.Bounds.HasValue)
        {
          Point3d maxPt = txt2.Bounds.Value.MaxPoint;
 
          // Place all four corners of the bounding box
          // in an array
 
          Point2d[] bounds =
            new Point2d[] {
              Point2d.Origin,
              new Point2d(0.0, maxPt.Y),
              new Point2d(maxPt.X, maxPt.Y),
              new Point2d(maxPt.X, 0.0)
            };
 
          // We're going to get each point's WCS coordinates
          // using the plane the text is on
 
          Plane pl = new Plane(txt.Position, txt.Normal);
 
          // Rotate each point and add its WCS location to the
          // collection
 
          foreach (Point2d pt in bounds)
          {
            pts.Add(
              pl.EvaluatePoint(
                pt.RotateBy(txt.Rotation, Point2d.Origin)
              )
            );
          }
        }
      }
    }
 
    private Circle CircleFromPoints(
      Point3dCollection pts, CoordinateSystem3d ucs, double buffer
    )
    {
      // Get the plane of the UCS
 
      Plane pl = new Plane(ucs.Origin, ucs.Zaxis);
 
      // We will project these (possibly 3D) points onto
      // the plane of the current UCS, as that's where
      // we will create our circle
 
      // Project the points onto it
 
      List<Point2d> pts2d = new List<Point2d>(pts.Count);
      for (int i = 0; i < pts.Count; i++)
      {
        pts2d.Add(pl.ParameterOf(pts[i]));
      }
 
      // Assuming we have some points in our list...
 
      if (pts.Count > 0)
      {
        // We need the center and radius of our circle
 
        Point2d center;
        double radius = 0;
 
        // Use our fast approximation algorithm to
        // calculate the center and radius of our
        // circle to within 1% (calling the function
        // with 100 iterations gives 10%, calling it
        // with 10K gives 1%)
 
        BadoiuClarksonIteration(
          pts2d, 10000, out center, out radius
        );
 
        // Get our center point in WCS (on the plane
        // of our UCS)
 
        Point3d cen3d = pl.EvaluatePoint(center);
 
        // Create the circle and add it to the drawing
 
        return new Circle(
          cen3d, ucs.Zaxis, radius * (1.0 + buffer)
        );
      }
      return null;
    }
 
    // Algorithm courtesy (and copyright of) Frank Nielsen
    // http://blog.informationgeometry.org/article.php?id=164
 
    public void BadoiuClarksonIteration(
      List<Point2d> set, int iter,
      out Point2d cen, out double rad
    )
    {
      // Choose any point of the set as the initial
      // circumcenter
 
      cen = set[0];
      rad = 0;
 
      for (int i = 0; i < iter; i++)
      {
        int winner = 0;
        double distmax = (cen - set[0]).Length;
 
        // Maximum distance point
 
        for (int j = 1; j < set.Count; j++)
        {
          double dist = (cen - set[j]).Length;
          if (dist > distmax)
          {
            winner = j;
            distmax = dist;
          }
        }
        rad = distmax;
 
        // Update
 
        cen =
          new Point2d(
            cen.X + (1.0 / (i + 1.0)) * (set[winner].X - cen.X),
            cen.Y + (1.0 / (i + 1.0)) * (set[winner].Y - cen.Y)
          );
      }
    }
  }
} 

One improvement suggested by Elson, after testing my initial implementation, was to provide the choice of creating multiple circles – one per selected entity – in the case where the user has selected multiple entities: a big time-saver if having to draw circles around a number of single polylines or block references.

As mentioned above, I realised quite early on that circles would not always want to be drawn to be touching (or even intersecting, given the margin of error) the enclosed geometry, so the above code supports the idea of a buffer. This is an amount – a percentage – by which to increase the radius when creating the circle. The code picks this value up via a new system variable (which can be added via the Registry from AutoCAD 2011) called ENCLOSINGCIRCLEBUFFER. Here’s the Registry file that can be used to add this system variable – an integer between 0 and 100 with a default value of 3:

Windows Registry Editor Version 5.00
 
[HKEY_LOCAL_MACHINE\SOFTWARE\Autodesk\AutoCAD\R18.1\ACAD-9001:409\Variables\ENCLOSINGCIRCLEBUFFER]
"StorageType"=dword:00000002
"LowerBound"=dword:00000000
"UpperBound"=dword:00000064
"PrimaryType"=dword:0000138b
@="3"

As not everyone can write to HKEY_LOCAL_MACHINE on their system – or is working with AutoCAD 2011 or higher – the code also will also use the value of the USERI1 system variable for this should it fail to find ENCLOSINGCIRCLEBUFFER.

Let’s take a look at the code working on the contents of Sample/Dynamic Blocks/Architectural – Metric.dwg. We’ll start by changing the buffer to 3% (after it having previously been set to zero in this session).

Command: ENCLOSINGCIRCLEBUFFER
Enter new value for ENCLOSINGCIRCLEBUFFER <0>: 3
Command: MEC
Select objects to enclose: ALL 9 found
Select objects to enclose:
Multiple objects selected: create individual circles around each one? [Yes/No] <No>: Y

Here are the changes to the geometry:

Overall the code should be reasonably straightforward – with the possible exception of the BadoiuClarksonIteration() function, which is certainly a black box to me.

It’s worth noting that while the points we gather from the geometry could be in 3D space – even if we’ve only really written the code to deal with 2D entities – we project them down to the plane of the UCS in order to create our circle there. As mentioned earlier, I do want to develop a 3D version of this – which shouldn’t be at all hard – to create a minimal enclosing sphere. The BadoiuClarksonIteration() function will need very little work – it would take a list of Point3d objects and also handle the Z coordinate of the center point – and we would need to develop the point collection code to also handle various types of solids and surfaces.

Once again, many thanks to Elson Brown for suggesting this topic – and helping with testing – and to Frank Nielsen for allowing me to adapt his code to address this problem.

Update

Added a missing Dispose() call.

Posted at 06:07 AM in AutoCAD, AutoCAD .NET, Geometry, Plugin of the Month | Permalink | Comments (2)

February 07, 2011

Gathering points defining 2D AutoCAD geometry using .NET

The reason for this post may be obvious to some – probably those who are doing this kind of analysis already – and less obvious to others – who will have to wait for the next post to see why it’s helpful. :-)

I won’t ruin the surprise, but suffice it to say that for various types of spatial analysis it’s helpful to acquire first points from geometry. This post attempts to do that for 2D geometry, and hopefully deals with a few of the trickier cases related to rotated text and such-like.

For this particular task I chose a recursive algorithm, as it’s common to have AutoCAD entities containing – or decomposable into – simpler entities. The fundamental approach is to Explode() complex entities – which doesn’t actually explode the entity inside AutoCAD, it just returns an array of the decomposed entities for (optional) adding to the drawing database – and then process the elements. We have some code in place to deal with the “leaves” of the geometry tree – the lines and other simple curves, the text, the points – and we recurse for the complex entities (the blocks, the groups, the polylines…).

For now we take the results and create DBPoints from them, just to see what we get.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Collections.Generic;
 
namespace PointGathering
{
  public class Commands
  {
    [CommandMethod("GP", CommandFlags.UsePickSet)]
    public void GatherPoints()
    {
      Document doc =
          Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask user to select entities
 
      PromptSelectionOptions pso =
        new PromptSelectionOptions();
      pso.MessageForAdding = "\nSelect entities to enclose: ";
      pso.AllowDuplicates = false;
      pso.AllowSubSelections = true;
      pso.RejectObjectsFromNonCurrentSpace = true;
      pso.RejectObjectsOnLockedLayers = false;
 
      PromptSelectionResult psr = ed.GetSelection(pso);
      if (psr.Status != PromptStatus.OK)
        return;
 
      // Collect points on the component entities
 
      Point3dCollection pts = new Point3dCollection();
 
      Transaction tr =
        db.TransactionManager.StartTransaction();
      using (tr)
      {
        BlockTableRecord btr =
          (BlockTableRecord)tr.GetObject(
            db.CurrentSpaceId,
            OpenMode.ForWrite
          );
 
        foreach (SelectedObject so in psr.Value)
        {
          Entity ent =
            (Entity)tr.GetObject(
              so.ObjectId,
              OpenMode.ForRead
            );
 
          // Collect the points for each selected entity
 
          Point3dCollection entPts = CollectPoints(tr, ent);
 
          // Add a physical DBPoint at each Point3d
 
          foreach(Point3d pt in entPts)
          {
            DBPoint dbp = new DBPoint(pt);
            btr.AppendEntity(dbp);
            tr.AddNewlyCreatedDBObject(dbp, true);
          }
        }
        tr.Commit();
      }
    }
 
    private Point3dCollection CollectPoints(
      Transaction tr, Entity ent
    )
    {
      // The collection of points to populate and return
 
      Point3dCollection pts = new Point3dCollection();
 
      // We'll start by checking a block reference for
      // attributes, getting their bounds and adding
      // them to the point list. We'll still explode
      // the BlockReference later, to gather points
      // from other geometry, it's just that approach
      // doesn't work for attributes (we only get the
      // AttributeDefinitions, which don't have bounds)
 
      BlockReference br = ent as BlockReference;
      if (br != null)
      {
        foreach (ObjectId arId in br.AttributeCollection)
        {
          DBObject obj = tr.GetObject(arId, OpenMode.ForRead);
          if (obj is AttributeReference)
          {
            AttributeReference ar = (AttributeReference)obj;
            ExtractBounds(ar, pts);
          }
        }
      }
 
      // If we have a curve - other than a polyline, which
      // we will want to explode - we'll get points along
      // its length
 
      Curve cur = ent as Curve;
      if (cur != null &&
          !(cur is Polyline ||
            cur is Polyline2d ||
            cur is Polyline3d))
      {
        // Two points are enough for a line, we'll go with
        // a higher number for other curves
 
        int segs = (ent is Line ? 2 : 20);
 
        double param = cur.EndParam - cur.StartParam;
        for (int i = 0; i < segs; i++)
        {
          try
          {
            Point3d pt =
              cur.GetPointAtParameter(
                cur.StartParam + (i * param / (segs - 1))
              );
            pts.Add(pt);
          }
          catch { }
        }
      }
      else if (ent is DBPoint)
      {
        // Points are easy
 
        pts.Add(((DBPoint)ent).Position);
      }
      else if (ent is DBText)
      {
        // For DBText we use the same approach as
        // for AttributeReferences
 
        ExtractBounds((DBText)ent, pts);
      }
      else if (ent is MText)
      {
        // MText is also easy - you get all four corners
        // returned by a function. That said, the points
        // are of the MText's box, so may well be different
        // from the bounds of the actual contents
 
        MText txt = (MText)ent;
        Point3dCollection pts2 = txt.GetBoundingPoints();
        foreach (Point3d pt in pts2)
        {
          pts.Add(pt);
        }
      }
      else if (ent is Face)
      {
        Face f = (Face)ent;
        try
        {
          for (short i = 0; i < 4; i++)
          {
            pts.Add(f.GetVertexAt(i));
          }
        }
        catch { }
      }
      else if (ent is Solid)
      {
        Solid sol = (Solid)ent;
        try
        {
          for (short i = 0; i < 4; i++)
          {
            pts.Add(sol.GetPointAt(i));
          }
        }
        catch { }
      }
      else
      {
        // Here's where we attempt to explode other types
        // of object
 
        DBObjectCollection oc = new DBObjectCollection();
        try
        {
          ent.Explode(oc);
          if (oc.Count > 0)
          {
            foreach (DBObject obj in oc)
            {
              Entity ent2 = obj as Entity;
              if (ent2 != null && ent2.Visible)
              {
                foreach (Point3d pt in CollectPoints(tr, ent2))
                {
                  pts.Add(pt);
                }
              }
              obj.Dispose();
            }
          }
        }
        catch { }
      }
      return pts;
    }
 
    private void ExtractBounds(
      DBText txt, Point3dCollection pts
    )
    {
      // We have a special approach for DBText and
      // AttributeReference objects, as we want to get
      // all four corners of the bounding box, even
      // when the text or the containing block reference
      // is rotated
 
      if (txt.Bounds.HasValue && txt.Visible)
      {
        // Create a straight version of the text object
        // and copy across all the relevant properties
        // (stopped copying AlignmentPoint, as it would
        // sometimes cause an eNotApplicable error)
 
        // We'll create the text at the WCS origin
        // with no rotation, so it's easier to use its
        // extents
 
        DBText txt2 = new DBText();
        txt2.Normal = Vector3d.ZAxis;
        txt2.Position = Point3d.Origin;
 
        // Other properties are copied from the original
 
        txt2.TextString = txt.TextString;
        txt2.TextStyleId = txt.TextStyleId;
        txt2.LineWeight = txt.LineWeight;
        txt2.Thickness = txt2.Thickness;
        txt2.HorizontalMode = txt.HorizontalMode;
        txt2.VerticalMode = txt.VerticalMode;
        txt2.WidthFactor = txt.WidthFactor;
        txt2.Height = txt.Height;
        txt2.IsMirroredInX = txt2.IsMirroredInX;
        txt2.IsMirroredInY = txt2.IsMirroredInY;
        txt2.Oblique = txt.Oblique;
 
        // Get its bounds if it has them defined
        // (which it should, as the original did)
 
        if (txt2.Bounds.HasValue)
        {
          Point3d maxPt = txt2.Bounds.Value.MaxPoint;
 
          // Place all four corners of the bounding box
          // in an array
 
          Point2d[] bounds =
            new Point2d[] {
              Point2d.Origin,
              new Point2d(0.0, maxPt.Y),
              new Point2d(maxPt.X, maxPt.Y),
              new Point2d(maxPt.X, 0.0)
            };
 
          // We're going to get each point's WCS coordinates
          // using the plane the text is on
 
          Plane pl = new Plane(txt.Position, txt.Normal);
 
          // Rotate each point and add its WCS location to the
          // collection
 
          foreach (Point2d pt in bounds)
          {
            pts.Add(
              pl.EvaluatePoint(
                pt.RotateBy(txt.Rotation, Point2d.Origin)
              )
            );
          }
        }
      }
    }
  }
}
 

I think it’s important to note one of the trickier cases this handles: while MText has a very handy GetBoundingPoints() method, DBText and AttributeReference (which derives from DBText) only implement the standard Entity.Bounds, which gives the bottom-left and top-right corners of the bounding box. As we ideally want to determine all four corners, we need to do a little more work. Taking the X and Y values and creating a box works well if the text isn’t rotated, but when the text is rotated the bounding box isn’t what we need:

To address this we take a copy of the DBText/AttributeReference – making sure it isn’t rotated – and then determine its four bounding points before rotating them to determine the actual corners of the text:

It should also be noted that we can’t rely on Explode() to get us the AttributeReferences to analyse: this returns AttributeDefinitions which do not have any geometric bounds. So we actually need to deal with block attributes as a special case, looking for AttributeReferences in each BlockReference and processing them separately.

To test our command, let’s run it on the sports car block from the Sample/Dynamic Blocks/Architectural – Imperial.dwg sample drawing.

And here it is after the GP command, with PDMODE set to 2:

Straight-line segments only have the end-points included in the set, but each curved segment (arc or spline) will have 20 points along its length (hence the areas of high density). You can tweak the code to generate more or fewer points for each segment type, as fits your needs.

In the next post, all will be revealed… :-)

Update

I’ve added support for Face and Solid objects to the above collection code: I found these entities used in blocks in AutoCAD’s sample folder (which probably means that others will be using them in similar circumstances). I should have thought of Solids, which are 2D, but was a little surprised to find Faces, which are generally 3D. Anyway – both have now been added.

Update 2

I realised when working on this more recent post that I was missing a Dispose() call on the results of Explode(). This has now been added.

Posted at 06:15 AM in AutoCAD, AutoCAD .NET, Blocks, Dynamic Blocks, Geometry | Permalink | Comments (7)

Through the Interface

Kean Walmsley

January 2012

Post Index

Reverse Index

Twitter Updates

Autodesk Blogs

February 2011

February 28, 2011

Implementing drag & drop of an AutoCAD raster image at a specified location and size using .NET

February 25, 2011

Implementing drag & drop at a specific location in AutoCAD using .NET

February 23, 2011

Managing drag & drop from a palette into AutoCAD using .NET

February 22, 2011

Back in the Bay Area

February 18, 2011

Comparing Explode with ExplodeFragments on AutoCAD MText

February 16, 2011

Exploding AutoCAD objects using .NET

February 14, 2011

Creating the smallest possible sphere around 3D AutoCAD geometry using .NET

February 11, 2011

Gathering points defining 3D AutoCAD geometry using .NET

February 09, 2011

Creating the smallest possible circle around 2D AutoCAD geometry using .NET

February 07, 2011

Gathering points defining 2D AutoCAD geometry using .NET

Feed/Share

Search

Categories

Recent Posts

Archives