Through the Interface: Overrules

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

Overrules

September 21, 2012

Overriding the grips of an AutoCAD polyline to maintain fillet segments using .NET

Many, many thanks to Massimo Cicognani for contributing the code in today’s post. Massimo contacted me as he was working through some issues with his implementation and then kindly offered to share it with this blog’s readers.

We’ve looked at a few different types of overrule on this blog, in the past, and even taken a look at a grip overrule or two. Massimo’s much more advanced grip overrule works with a very particular type of polyline: those that alternate between straight and arc segments (with the first and last segments being straight). This might sound a touch specific, unless of course you’re working with such polylines on a regular basis to represent pipes, etc.

The code is split into two C# source files. The first contains the implementation of the overrule and the command to toggle it on and off.

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.GraphicsInterface;
using Autodesk.AutoCAD.EditorInput;
using System.Collections.Generic;
using System;
 
namespace comsPLine
{
  // Derived class for grip handling
 
  public class myGripData : GripData
  {
    // Object id of the original entity
 
    public ObjectId m_key = ObjectId.Null;
 
    // Progressive grip number
 
    public int m_index = 0;
 
    // Previous radius at this grip vertex
 
    public Double m_radius = 0.0;
 
    // Original grip location
 
    public Point3d m_original_point = Point3d.Origin;
 
    public override void OnGripStatusChanged(
      ObjectId entityId, GripData.Status newStatus
    )
    {
      if (newStatus == Status.GripAbort)
      {
        // Revert grips to original location
 
        GripVectorOverrule.ResetGrips(entityId);
      }
    }
 
    public override bool ViewportDraw(
      ViewportDraw worldDraw,
      ObjectId entityId,
      GripData.DrawType type,
      Point3d? imageGripPoint,
      int gripSizeInPixels
    )
    {
      // Calculate the size of the glyph in WCS
 
      Point2d glyphSize =
        worldDraw.Viewport.GetNumPixelsInUnitSquare(this.GripPoint);
      Double glyphHeight = (gripSizeInPixels / glyphSize.Y);
 
      // Transform to viewport
 
      Matrix3d e2w = worldDraw.Viewport.EyeToWorldTransform;
      Point3d pt = this.GripPoint.TransformBy(e2w);
 
      // Draw a glyph
 
      Point3dCollection pnts = new Point3dCollection();
      pnts.Add(
        new Point3d(pt.X - glyphHeight, pt.Y + glyphHeight, pt.Z)
      );
      pnts.Add(new Point3d(pt.X, pt.Y - glyphHeight, pt.Z));
      pnts.Add(
        new Point3d(pt.X + glyphHeight, pt.Y + glyphHeight, pt.Z)
      );
      pnts.Add(
        new Point3d(pt.X - glyphHeight, pt.Y + glyphHeight, pt.Z)
      );
 
      worldDraw.Geometry.DeviceContextPolygon(pnts);
 
      return false;
    }
  }
 
  // This class is instantiated by AutoCAD for each document when
  // a command is called by the user the first time in the context
  // of a given document. In other words, non static data in this
  // class is implicitly per-document!
 
  public class GripVectorOverrule : GripOverrule
  {
    // A static pointer to our overrule instance
 
    static public GripVectorOverrule theOverrule =
      new GripVectorOverrule();
 
    // A flag to indicate whether we're overruling
 
    static bool overruling = false;
 
    // gripdata for each selected polyline
 
    static Dictionary<ObjectId, GripDataCollection> _ents_handled =
      new Dictionary<ObjectId, GripDataCollection>();
 
 
    public GripVectorOverrule()
    {
      // Set event handlers on documents to get access to
      // OnImpliedSelectionChanged
 
      DocumentCollection dm = Application.DocumentManager;
 
      dm.DocumentCreated +=
        new DocumentCollectionEventHandler(dm_DocumentCreated);
      dm.DocumentToBeDestroyed +=
        new DocumentCollectionEventHandler(dm_DocumentToBeDestroyed);
 
      // Attach handler to currently loaded documents
 
      foreach (Document doc in dm)
      {
        doc.ImpliedSelectionChanged +=
          new EventHandler(doc_ImpliedSelectionChanged);
      }
    }
 
    void dm_DocumentCreated(
      object sender, DocumentCollectionEventArgs e
    )
    {
      e.Document.ImpliedSelectionChanged +=
        new EventHandler(doc_ImpliedSelectionChanged);
    }
 
    void dm_DocumentToBeDestroyed(
      object sender, DocumentCollectionEventArgs e
    )
    {
      e.Document.ImpliedSelectionChanged -=
        new EventHandler(doc_ImpliedSelectionChanged);
    }
 
    void doc_ImpliedSelectionChanged(object sender, EventArgs e)
    {
      // Check for empty selection on current document
 
      Document doc = Application.DocumentManager.MdiActiveDocument;
      PromptSelectionResult res = doc.Editor.SelectImplied();
 
      // If nothing selected, it's a good time to reset GripData
      // dictionary
 
      if (res != null)
        if (res.Value == null) GripVectorOverrule.ResetAllGrips();
    }
 
    /// <summary>
    /// Called when entity is first selected.
    /// Analyze it and return alternative grips data collection if
    /// we must handle it.
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="grips"></param>
    /// <param name="curViewUnitSize"></param>
    /// <param name="gripSize"></param>
    /// <param name="curViewDir"></param>
    /// <param name="bitFlags"></param>
 
    public override void GetGripPoints(
      Entity entity,
      GripDataCollection grips,
      double curViewUnitSize,
      int gripSize,
      Vector3d curViewDir,
      GetGripPointsFlags bitFlags
    )
    {
      bool bValid = false;
 
      // get polyline object
 
      Autodesk.AutoCAD.DatabaseServices.Polyline p =
        entity as Autodesk.AutoCAD.DatabaseServices.Polyline;
 
      // check if the polyline is of the type we search for.
      // In the final version it may contain some xdata, maybe 
      // holding a fixed radius value, to allow other plines to
      // work as expected.
      // However, we must always check if the geometry is still
      // valid. We should also check if the linear segments are
      // tangent to the arcs, but for the moment, we'll check if
      // we have a pattern of alternating line and arc segments,
      // starting with a line
 
      bValid = csMath.IsPolylineRoundedEdge(p);
 
      if (bValid)
      {
        // seems right, gather line segments
 
        LineSegment3d[] lsegs =
          new LineSegment3d[p.NumberOfVertices];
        int nSegs = 0;
 
        for (int i = 0; i < p.NumberOfVertices; i++)
        {
          if (p.GetSegmentType(i) == SegmentType.Line)
          {
            lsegs[nSegs++] = p.GetLineSegmentAt(i);
          }
        }
 
        // Gather start, end and intersection points
 
        Point3d[] pnts = new Point3d[p.NumberOfVertices];
 
        // Current radius for inner intersection
 
        Double[] rads = new Double[p.NumberOfVertices];
        int nPnts = 0;
 
        // At least two linear segments are needed
 
        if (nSegs > 1) 
        {
          // Working plane for intersecting segments
 
          Plane pPlane = p.GetPlane();
 
          // Temporary intersecting point
 
          Point3d pnt = Point3d.Origin;
 
          // First point: if the polyline id closed, the first pt
          // is the intersection of the first and last segments
          if (p.Closed)
          {
            if (
              csMath.CheckIntersect(
                lsegs[0], lsegs[nSegs - 1], pPlane, ref pnt
              )
            )
            {
              pnts[nPnts] = pnt;
              rads[nPnts] =
                csMath.GetFilletRadius(
                  lsegs[0], lsegs[nSegs - 1], pPlane
                );
              nPnts++;
            }
            else
            {
              // Polyline with overlapping segments? Not good for us
 
              bValid = false;
            }
          }
          else
            pnts[nPnts++] = lsegs[0].StartPoint;
 
          // Add intersection points for internal segments
 
          for (int i = 0; i < (nSegs - 1); i++)
          {
            if (
              csMath.CheckIntersect(
                lsegs[i], lsegs[i + 1], pPlane, ref pnt
              )
            )
            {
              pnts[nPnts] = pnt;
              rads[nPnts] =
                csMath.GetFilletRadius(
                  lsegs[i], lsegs[i + 1], pPlane
                );
              nPnts++;
            }
            else
            {
              // No intersection, overlapping or co-linear segments?
 
              bValid = false;
            }
          }
 
          // Last point: add if not a closed pline
 
          if (!p.Closed) pnts[nPnts++] = lsegs[nSegs - 1].EndPoint;
 
          if (bValid) // Still valid?
          {
            // Everything seems ok, add grip points
            // Use also a private GripDataCollection, don't mess
            // with AutoCAD's
 
            GripDataCollection myGrips = new GripDataCollection();
 
            for (int i = 0; i < nPnts; i++)
            {
              myGripData gd = new myGripData();
              gd.m_index = i;
              gd.m_key = entity.ObjectId;
              gd.GripPoint = gd.m_original_point = pnts[i];
              gd.m_radius = rads[i];
              gd.GizmosEnabled = true;
              grips.Add(gd);
              myGrips.Add(gd);
            }
 
            // Check for same entity already in list. If so,
            // remove it
 
            _ents_handled.Remove(entity.ObjectId);
 
            // Add to our managed list
 
            _ents_handled.Add(entity.ObjectId, myGrips);
          }
        }
        else
        {
          bValid = false;
        }
      }
 
      if (!bValid)
      {
        // Polyline not good for us, let it be treated as usual
 
        base.GetGripPoints(
          entity, grips, curViewUnitSize,
          gripSize, curViewDir, bitFlags
        );
      }
    }
 
    /// <summary>
    /// Handler called during grip streching.
    /// Rebuild polyline on the fly given modified grips
    /// </summary>
    /// <param name="entity">Clone of the original entity to
    /// manage</param>
    /// <param name="grips">Altered grips</param>
    /// <param name="offset">Vector of displacement from original
    /// grip position</param>
    /// <param name="bitFlags"></param>
 
    public override void MoveGripPointsAt(
      Entity entity,
      GripDataCollection grips,
      Vector3d offset,
      MoveGripPointsFlags bitFlags
    )
    {
      // Retrieve from the streched grips the ObjectId/dictionary
      // key
 
      // shouldn't happen. Programmer's paranoia
 
      if (grips.Count == 0) return;
 
      myGripData gda = grips[0] as myGripData;
      if (gda != null) // It's one of our grips
      {
        if (_ents_handled.ContainsKey(gda.m_key))
        {
          // Retrieve our original grip collection
 
          GripDataCollection original_grips =
            _ents_handled[gda.m_key];
 
          // Correct grips with offset information
 
          foreach (myGripData gdo in grips)
          {
            // Retrieve original grip and set current
            // dragged location
 
            myGripData gd =
              original_grips[gdo.m_index] as myGripData;
 
            gd.GripPoint = gd.m_original_point + offset;
          }
 
          // Recalc polyline from new sets of grips
 
          csMath.RebuildPolyline(
            entity as Autodesk.AutoCAD.DatabaseServices.Polyline,
            original_grips
          );
 
          // Done, don't fall into standard handling
 
          return;
        }
      }
 
      // Revert to standard handling
 
      base.MoveGripPointsAt(entity, grips, offset, bitFlags);
    }
 
    /// <summary>
    /// Reset grip position for the selected entity.
    /// Revert position to initial location, useful when aborting 
    /// a grip handling.
    /// </summary>
    /// <param name="entity_id">objectid/key of the selected
    /// entity</param>
 
    public static void ResetGrips(ObjectId entity_id)
    {
      // Reset grips to their original point
 
      if (_ents_handled.ContainsKey(entity_id))
      {
        GripDataCollection grips = _ents_handled[entity_id];
 
        foreach (myGripData gdo in grips)
        {
          gdo.GripPoint = gdo.m_original_point;
        }
      }
    }
 
    public static void ResetAllGrips()
    {
      // Clear handled list, to be called when selection is cleared
 
      _ents_handled.Clear();
    }
 
    [CommandMethod("GOO")]
    public void GripOverruleOnOff()
    {
      Document doc = Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
 
      if (overruling)
      {
        ObjectOverrule.RemoveOverrule(
          RXClass.GetClass(
            typeof(Autodesk.AutoCAD.DatabaseServices.Polyline)
          ),
          GripVectorOverrule.theOverrule
        );
      }
      else
      {
        ObjectOverrule.AddOverrule(
          RXClass.GetClass(
            typeof(Autodesk.AutoCAD.DatabaseServices.Polyline)
          ),
          GripVectorOverrule.theOverrule,
          true
        );
      }
 
      overruling = !overruling;
 
      GripOverrule.Overruling = overruling;
 
      ed.WriteMessage(
        "\nGrip overruling turned {0}.",
        overruling ? "on" : "off"
      );
    }
  }
}

The second contains mathematical support functions – that Massimo has developed over many years, so it’s especially nice of him to share these (he even translated the bulk of the comments from Italian! :-).

// (C) Copyright 2008-2012 by COMSAL Srl - RSM
//
// COMSAL PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS. 
// COMSAL SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE. 
// COMSAL SRL DOES NOT WARRANT THAT THE OPERATION OF THE
// PROGRAM WILL BE UNINTERRUPTED OR ERROR FREE.
//
// Description:
// Classe di supporto per funzioni geometriche comuni
//
// History:
// 02.10.2008 [MC] Prima stesura
//
//
 
using System;
using System.Collections.Generic;
using System.Text;
 
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.GraphicsSystem;
 
namespace comsPLine
{
  // Support class for non-trigonometric math
 
  public class csCosDir
  {
    public Double cx;
    public Double cy;
    public Double cz;
 
    public csCosDir()
    {
      cx = cy = cz = 0.0;
    }
 
    public csCosDir(Point2d p1, Point2d p2)
    {
      Double dx = p2.X - p1.X;
      Double dy = p2.Y - p1.Y;
      Double dd = Math.Sqrt(dx * dx + dy * dy);
 
      if (dd > csMath.dEpsilon)
      {
        cx = dx / dd;
        cy = dy / dd;
      }
    }
 
    public csCosDir(Point3d p1, Point3d p2)
    {
      Double dx = p2.X - p1.X;
      Double dy = p2.Y - p1.Y;
      Double dz = p2.Z - p1.Z;
      Double dd = Math.Sqrt(dx * dx + dy * dy + dz * dz);
 
      if (dd > csMath.dEpsilon)
      {
        cx = dx / dd;
        cy = dy / dd;
        cz = dz / dd;
      }
    }
  }
 
  // Generic info holder for polyline vertex with fillet
 
  public class myVertex
  {
    public Double radius; // Fillet radius (requested or real)
    public Point3d pOrg;  // Origin of the fillet arc
    public Point3d p1;    // Arc start point (end of 1st segment)
    public Point3d p2;    // Arc end point (start of 2nd segment)
    public Point3d pc;    // Arc mid point laying on the bisectrix
    public Double bulge;  // Bulge parameter as usual: B=2*H/D
 
    public myVertex()
    {
      pOrg = p1 = p2 = pc = Point3d.Origin;
      radius = bulge = 0.0;
    }
 
    public myVertex(Point3d pInit)
    {
      pOrg = p1 = p2 = pc = pInit;
      radius = bulge = 0.0;
    }
  }
 
  // Common math functions
 
  public static class csMath
  {
    public const Double PI =
      3.141592653589793; // More decimal places than Math.PI
    public const Double dEpsilon =
      0.001; // General precision allowed for identity
 
 
    /// <summary>
    /// Check if the polyline topology is compatible with a
    /// sequence of segments with internal rounded edges.
    /// Used to activate an alternate grip handling where
    /// user can control segment vertexes through apparent
    /// intersections.
    /// </summary>
    /// <param name="p">Polyline to check</param>
    /// <returns>Compatibility with alternate grip handling</returns>
 
    public static bool IsPolylineRoundedEdge(Polyline p)
    {
      bool result = false;
 
      if (p != null)
      {
        // Quick check if it contains at least one arc and two
        // segments, that means at least 4 points also check
        // for planar entity
 
        if (p.IsPlanar && p.HasBulges && (p.NumberOfVertices > 3))
        {
          SegmentType prevType = p.GetSegmentType(0);
 
          // First segment must be a line
 
          if (prevType == SegmentType.Line)
          {
            result = true;
            for (int i = 1; i < p.NumberOfVertices; i++)
            {
              SegmentType currType = p.GetSegmentType(i);
              if (
                currType == SegmentType.Line ||
                currType == SegmentType.Arc
              )
              {
                if (currType == prevType)
                {
                  result = false;
                  break;
                }
 
                prevType = currType;
              }
            }
 
            // Check if also the last segment is a line, or if
            // it's an arc, the polyline must be closed, like
            // a rounded box
 
            if (
              prevType == SegmentType.Arc && !p.Closed
            )
              result = false;
          }
        }
      }
      return result;
    }
 
    /// <summary>
    /// Rebuild polyline with new grip information
    /// </summary>
    /// <param name="polyline">Polyline to be rebuilt</param>
    /// <param name="original_grips">Grips collection</param>
 
    public static void RebuildPolyline(
      Polyline p, GripDataCollection grips
    )
    {
      try
      {
        int nPnt = grips.Count;
 
        // Create vertex info from gripdata collection
 
        myVertex[] vFill = new myVertex[nPnt];
 
        // Initializa first and last vertex with first and
        // last grip points
 
        vFill[0] = new myVertex(grips[0].GripPoint);
        vFill[nPnt - 1] =
          new myVertex(grips[grips.Count - 1].GripPoint);
 
        // Retrieve adjacent segments (three consecutive points)
 
        for (int i = 1; i < (nPnt - 1); i++)
        {
          myGripData gd_prev = grips[i - 1] as myGripData;
          myGripData gd_center = grips[i] as myGripData;
          myGripData gd_next = grips[i + 1] as myGripData;
 
          // New vertex info
 
          vFill[i] = new myVertex();
          vFill[i].radius = gd_center.m_radius;
 
          // Calc fillet information, if possible with current 
          // radius and segments length
 
          if (
            !csMath.LinesFillet(
              gd_center.GripPoint,
              gd_prev.GripPoint,
              gd_next.GripPoint,
              ref vFill[i],
              true
            )
          )
          {
            // Unable to find a solution, remove fillet information
 
            vFill[i].p1 = vFill[i].p2 = vFill[i].pc =
              vFill[i].pOrg = gd_center.GripPoint;
            vFill[i].radius = 0.0;
          }
        }
 
        if (p.Closed)
        {
          // Add vertex information on last grip
 
          myGripData gd_prev = grips[grips.Count - 2] as myGripData;
          myGripData gd_center =
            grips[grips.Count - 1] as myGripData;
          myGripData gd_next = grips[0] as myGripData;
 
          // Last point may coincident with first or not
 
          if (
            gd_center.GripPoint.DistanceTo(gd_prev.GripPoint) <
            csMath.dEpsilon
          )
            gd_prev = grips[grips.Count - 3] as myGripData;
 
          vFill[nPnt - 1] = new myVertex();
          vFill[nPnt - 1].radius = gd_center.m_radius;
 
          // Calc fillet information, if possible with current
          // radius and segments length
 
          if (
            !csMath.LinesFillet(
              gd_center.GripPoint,
              gd_prev.GripPoint,
              gd_next.GripPoint,
              ref vFill[nPnt - 1],
              false)
          )
          {
            // Unable to find a solution, remove fillet information
 
            vFill[nPnt - 1].p1 = vFill[nPnt - 1].p2 =
              vFill[nPnt - 1].pc = vFill[nPnt - 1].pOrg =
                gd_center.GripPoint;
            vFill[nPnt - 1].radius = 0.0;
          }
 
          // Recalc vertex information on first grip
 
          gd_prev = grips[grips.Count - 1] as myGripData;
          gd_center = grips[0] as myGripData;
          gd_next = grips[1] as myGripData;
 
          // Last point may coincident with first or not
 
          if (
            gd_center.GripPoint.DistanceTo(gd_prev.GripPoint) <
            csMath.dEpsilon
          )
            gd_prev = grips[grips.Count - 2] as myGripData;
 
          vFill[0] = new myVertex();
          vFill[0].radius = gd_center.m_radius;
 
          // Calc fillet information, if possible with
          // current radius and segments length
 
          if (
            !csMath.LinesFillet(
              gd_center.GripPoint,
              gd_prev.GripPoint,
              gd_next.GripPoint,
              ref vFill[0],
              false
            )
          )
          {
            // Unable to find a solution, remove fillet information
            vFill[0].p1 = vFill[0].p2 = vFill[0].pc =
              vFill[0].pOrg = gd_center.GripPoint;
            vFill[0].radius = 0.0;
          }
        }
 
        // Everything seem ok, rebuild polyline
 
        bool bIsClosed = p.Closed; // remember if original was closed
 
        // Clear current points definitions
 
        p.Closed = false;
        while (p.NumberOfVertices > 1)
          p.RemoveVertexAt(0); // Cannot completely clear points
 
        // Add new points and segments definition
 
        for (int i = 0; i < (nPnt - 1); i++)
        {
          // Add linesegment only if lenght is not null
 
          if (
            vFill[i].p2.DistanceTo(vFill[i + 1].p1) >
            csMath.dEpsilon
          )
            p.AddVertexAt(
              p.NumberOfVertices,
              new Point2d(vFill[i].p2.X, vFill[i].p2.Y),
              0, 0, 0
            );
 
          // End point always valid with bulge information if needed
 
          p.AddVertexAt(
            p.NumberOfVertices,
            new Point2d(vFill[i + 1].p1.X, vFill[i + 1].p1.Y),
            vFill[i + 1].bulge, 0, 0
          );
        }
 
        p.RemoveVertexAt(0); // Remove last of old points
 
        // If closed re-add first point with bulge
 
        if (bIsClosed)
        {
          // Add linesegment only if length is not null
 
          if (
            vFill[nPnt - 1].p2.DistanceTo(vFill[0].p1) >
            csMath.dEpsilon
          )
            p.AddVertexAt(
              p.NumberOfVertices,
              new Point2d(
                vFill[nPnt - 1].p2.X,
                vFill[nPnt - 1].p2.Y
              ),
              0, 0, 0
            );
 
          // End point always valid with bulge information if needed
 
          p.AddVertexAt(
            p.NumberOfVertices,
            new Point2d(vFill[0].p1.X, vFill[0].p1.Y),
            vFill[0].bulge, 0, 0
          );
 
          p.Closed = true; // Restore closed status
        }
      }
      catch { }
    }
 
    /// <summary>
    /// Compute fillet information for two converging segments.
    /// The fillet information is returned through a myVertex class
    /// that will hold information about the arc start point on the
    /// first segment, the end point on the second segment, the arc
    /// origin and the arc midpoint on the bisetrix
    /// </summary>
    /// <param name="pOrg">Intersection point of the segments</param>
    /// <param name="p1">Start point of the first segment</param>
    /// <param name="p2">End point of the second segment</param>
    /// <param name="v">Info class with requested radius to be
    /// filled with fillet info</param>
    /// <returns>True if a fillet is possible, false if no solution
    /// can be found</returns>
 
    public static bool LinesFillet(
      Point3d pOrg,
      Point3d p1,
      Point3d p2,
      ref myVertex v,
      bool bAllowRadiusReduction
    )
    {
      try
      {
        bool bInversionOccured = false;
 
        // Check point validity
 
        Double d1 = pOrg.DistanceTo(p1);
        Double d2 = pOrg.DistanceTo(p2);
        Double dd = p1.DistanceTo(p2);
 
        if (d1 < csMath.dEpsilon)
          return false; // Segment p1-porg null
        if (d2 < csMath.dEpsilon)
          return false; // Segment p2-porg null
        if (dd < csMath.dEpsilon)
          return false; // Overlapping segments
        if (Math.Abs(dd - d1 - d2) < csMath.dEpsilon)
          return false; // Co-linear segments
        if (v.radius < csMath.dEpsilon)
          return false; // Radius too small
 
        // Sort points to keep the smaller angle always as p1-pOrg-p2
 
        if (csMath.DistFromLine(pOrg, p1, p2) < 0)
        {
          // Point p2 is on the left side of vector pOrg->p1
          // should be on the right: switch points
 
          Point3d pp = p2;
          p2 = p1;
          p1 = pp;
          bInversionOccured = true;  // Mark that inversion occurred
        }
 
        // Get sine/cosine coefficients
 
        csCosDir r1 = new csCosDir(pOrg, p1);
        csCosDir r2 = new csCosDir(pOrg, p2);
 
        // Get bisetrix where arc origin and midpoint lay
 
        csCosDir rb = new csCosDir();
 
        // Shouldn't happen, co-linear segments already checked
 
        if (!csMath.FindBisect(r1, r2, ref rb))
          return false;
 
        // The bisetrix and the projection of the arc origin on
        // either segment forms a rect triangle. Align segment
        // coefficient to X axis, so the radius would be aligned
        // to Y axis
 
        Double cxr = rb.cx * r1.cx + rb.cy * r1.cy;
        Double cyr = -rb.cx * r1.cy + rb.cy * r1.cx;
 
        // Get hypotenuse given the radius and sine coefficient
 
        Double ipo = v.radius / cyr;
 
        // Get other catete: distance from pOrg and the fillet
        // points on segments
 
        Double l1 = ipo * cxr;
 
        // If allowed, check if fillet point lays outside the
        // smallest segment lenght
 
        if (bAllowRadiusReduction)
        {
          Double dmin = (d1 < d2) ? d1 : d2;
 
          if (l1 > dmin)
          {
            // Reduce radius to keep fillet inside segment
 
            v.radius = dmin * cyr / cxr;
 
            // Use new radius for computation
 
            ipo = v.radius / cyr;
            l1 = ipo * cxr;
          }
        }
 
        // Given the length, get arc start and end points on
        // each segment. Beware of segment switch, if occurred
 
        if (bInversionOccured)
        {
          v.p2 =
            new Point3d(
              pOrg.X + l1 * r1.cx, pOrg.Y + l1 * r1.cy, 0.0
            );
          v.p1 =
            new Point3d(
              pOrg.X + l1 * r2.cx, pOrg.Y + l1 * r2.cy, 0.0
            );
        }
        else
        {
          v.p1 =
            new Point3d(
              pOrg.X + l1 * r1.cx, pOrg.Y + l1 * r1.cy, 0.0
            );
          v.p2 =
            new Point3d(
              pOrg.X + l1 * r2.cx, pOrg.Y + l1 * r2.cy, 0.0
            );
        }
 
        // Get arc midpoint on bisetrix
 
        v.pc =
          new Point3d(
            pOrg.X + (ipo - v.radius) * rb.cx,
            pOrg.Y + (ipo - v.radius) * rb.cy,
            0.0
          );
 
        // Get arc origin
 
        v.pOrg =
          new Point3d(
            pOrg.X + ipo * rb.cx, pOrg.Y + ipo * rb.cy, 0.0
          );
 
        // Compute bulge using the formula B = 2*H/D, where D is
        // the chord and H the distance of the chord midpoint
        // and the arc midpoint
 
        Double D = v.p1.DistanceTo(v.p2);
        Double H = Math.Abs(csMath.DistFromLine(v.p1, v.p2, v.pc));
        if (D > csMath.dEpsilon) v.bulge = 2 * H / D;
 
        // Bulge should be positive for counterclockwise arcs and
        // negative for clockwise. Adjust sign according with
        // segment order switch, if occurred
 
        if (!bInversionOccured) v.bulge = -v.bulge;
      }
      catch (Exception ex)
      {
        System.Diagnostics.Debug.WriteLine(
          "[LinesFillet]" + ex.Message
        );
        return false;
      }
 
      return true;
    }
 
    /// <summary>
    /// Get plausible fillet radius from two converging linesegments
    /// </summary>
    /// <param name="l1">First segment</param>
    /// <param name="l2">Second segment</param>
    /// <param name="pPlane">Working plane</param>
    /// <param name="pOut">Resulting point, if available</param>
    /// <returns></returns>
 
    public static Double GetFilletRadius(
      LineSegment3d l1, LineSegment3d l2, Plane pPlane
    )
    {
      Double result = 0.0;
 
      // Get 2d points on working plane
 
      Point2d p1 = l1.StartPoint.Convert2d(pPlane);
      Point2d p2 = l1.EndPoint.Convert2d(pPlane);
 
      Point2d q1 = l2.StartPoint.Convert2d(pPlane);
      Point2d q2 = l2.EndPoint.Convert2d(pPlane);
 
      Point2d pInt = Point2d.Origin;
 
      // Get intersection point
 
      IntersectLinesState res =
        IntersectLines(p1, p2, q1, q2, out pInt);
      if (
        res == IntersectLinesState.ApparentIntersect ||
        res == IntersectLinesState.RealIntersect
      )
      {
        // Get the endpoints closest to the intersection
 
        Point2d l1_end =
          p1.GetDistanceTo(pInt) < p2.GetDistanceTo(pInt) ? p1 : p2;
        Point2d l2_end =
          q1.GetDistanceTo(pInt) < q2.GetDistanceTo(pInt) ? q1 : q2;
 
        // Throw a perpendicular vector on the endpoints closest
        // to the intersection
 
        Line2d lp1 =
          new LineSegment2d(p1, p2).GetPerpendicularLine(l1_end);
        Line2d lp2 =
          new LineSegment2d(q1, q2).GetPerpendicularLine(l2_end);
 
        // Get intersection of projection lines (center of fillet,
        // if segments already have fillet)
 
        Point2d[] pInts = lp1.IntersectWith(lp2);
        if (pInts != null)
        {
          // Get distance of center of fillet from endpoints
 
          Double r1 = l1_end.GetDistanceTo(pInts[0]);
          Double r2 = l2_end.GetDistanceTo(pInts[0]);
 
          // If the two segments were already rounded, the two
          // distances should be the same and equals to the fillet
          // radius. If the segments have been moved or stretched,
          // the distances may differ. We take the lower radius
          // as the minimum fillet radius available
 
          result = Math.Min(r1, r2);
        }
      }
 
      return result;
    }
 
 
    /// <summary>
    /// Check intersection for two segments on plane pPlane
    /// </summary>
    /// <param name="l1">First segment</param>
    /// <param name="l2">Second segment</param>
    /// <param name="pPlane">Working plane</param>
    /// <param name="pOut">Resulting point, if available</param>
    /// <returns></returns>
 
    public static bool CheckIntersect(
      LineSegment3d l1,
      LineSegment3d l2,
      Plane pPlane,
      ref Point3d pOut
    )
    {
      bool result = false;
 
      // Get 2d points on working plane
 
      Point2d p1 = l1.StartPoint.Convert2d(pPlane);
      Point2d p2 = l1.EndPoint.Convert2d(pPlane);
 
      Point2d q1 = l2.StartPoint.Convert2d(pPlane);
      Point2d q2 = l2.EndPoint.Convert2d(pPlane);
 
      Point2d pInt = Point2d.Origin;
 
      IntersectLinesState res =
        IntersectLines(p1, p2, q1, q2, out pInt);
      if (
        res == IntersectLinesState.ApparentIntersect ||
        res == IntersectLinesState.RealIntersect
      )
      {
        pOut = new Point3d(pPlane, pInt);
        result = true;
      }
 
      return result;
    }
 
    /// <summary>
    /// Possible results for IntersectLines() function
    /// </summary>
 
    public enum IntersectLinesState
    {
      InvalidPoints = -1,    // Invalid points (coincident?)
      RealIntersect = 0,     // Real intersection found, pInt valid
      ApparentIntersect = 1, // Apparent inters. found, pInt valid
      NoIntersection = 2,    // Segments are parallel
      OverLapping = 3,       // Segments are overlapping
      Colinear = 4           // Segments are co-linear
    }
 
    /// <summary>
    /// Try to get intersection point of two segment.
    /// The intersection may be real or apparent.
    /// The resulting point is 
    /// </summary>
    /// <param name="p1">Start point of first segment</param>
    /// <param name="p2">End point of first segment</param>
    /// <param name="q1">Start point of second segment</param>
    /// <param name="q2">End point of second segment</param>
    /// <param name="pInt">[out] Resulting intersection point</param>
    /// <returns>Result validity state</returns>
    /// 
    public static IntersectLinesState IntersectLines(
      Point2d p1, Point2d p2, // First segment
      Point2d q1, Point2d q2, // Second segment
      out Point2d pInt        // Intersecting point
    )
    {
      IntersectLinesState result =
        IntersectLinesState.NoIntersection;
      pInt = Point2d.Origin;
 
      // Get sine/cosine coefficients for the two segments
 
      csCosDir r1 = new csCosDir(p1, p2);
      csCosDir r2 = new csCosDir(q1, q2);
 
      // Check coefficients, if points are coincident,
      // segments are null
 
      if (
        (r1.cx == 0.0 && r1.cy == 0.0) ||
        (r2.cx == 0.0 && r2.cy == 0.0)
      )
      {
        // Coincident points? Invalid segments data
 
        return IntersectLinesState.InvalidPoints;
      }
 
      // Intersection coefficients
 
      Double a1 = r1.cx, a2 = r1.cy;
      Double b1 = -r2.cx, b2 = -r2.cy;
      Double c1 = q1.X - p1.X, c2 = q1.Y - p1.Y;
 
      // Get denominator, if null, segments have same direction
 
      Double dden = a1 * b2 - a2 * b1;
 
      if (Math.Abs(dden) > csMath.dEpsilon)
      {
        // Valid denominator, lines are not parallels or co-linear
        // now, intersection linear parameter may be get either
        // from first or second segment. Do both to check for
        // real or apparent intersection.
 
        // Linear parameter for second segment
 
        Double tt = (c1 * b2 - c2 * b1) / dden;
 
        // Linear parameter for first segment
 
        Double vv = (c2 * a1 - c1 * a2) / dden;
 
        // Intersection point from first segment parameter
 
        pInt = new Point2d(q1.X + r2.cx * vv, q1.Y + r2.cy * vv);
 
        // To be 'real', intersection point must lay on both
        // segments (parameter from 0 to 1). Otherwise, we set
        // it as 'apparent'. Get normalized linear parameter
        // (at this stage denominator are intrinsicly valid,
        // no need to check for DIVBYZERO)
 
        tt = tt / p1.GetDistanceTo(p2);
        vv = vv / q1.GetDistanceTo(q2);
 
        // Check if both coefficients lay within 0 and 1
 
        if (
          tt > -csMath.dEpsilon && tt < (1 + csMath.dEpsilon) &&
          vv > -csMath.dEpsilon && vv < (1 + csMath.dEpsilon)
        )
        {
          result = IntersectLinesState.RealIntersect;
        }
        else
        {
          result = IntersectLinesState.ApparentIntersect;
        }
      }
      else
      {
        // Segments are parallel or co-linear (have same direction).
        // Check coefficients for a new connecting segment with
        // points taken from both original segment. If coefficients
        // are the same, segments are co-linear, otherwise are
        // parallel
 
        csCosDir rx;
 
        // Avoid coincident points
 
        if (p1.GetDistanceTo(q1) > csMath.dEpsilon)
          rx = new csCosDir(p1, q1);
        else
          rx = new csCosDir(p1, q2);
 
        if (Math.Abs(rx.cx - r1.cx) < csMath.dEpsilon &&
            Math.Abs(rx.cy - r1.cy) < csMath.dEpsilon
        )
        {
          // Same coefficient, segments lay on the same vector.
          // Check if there is any overlapping by checking distances
          // from the two ends of a segments and another end.
          // Sum of distances must be equal or higher than segment 
          // length, otherwise they are partially overlapping
 
          Double ll = p2.GetDistanceTo(p1);
 
          bool bOver1 =
            q1.GetDistanceTo(p1) + q1.GetDistanceTo(p2) >
              ll + csMath.dEpsilon;
          bool bOver2 =
            q2.GetDistanceTo(p1) + q2.GetDistanceTo(p2) >
              ll + csMath.dEpsilon;
 
          result =
            bOver1 && bOver2 ?
              IntersectLinesState.Colinear :
              IntersectLinesState.OverLapping;
        }
        else
        {
          // Parallel segments, no intersection
 
          result = IntersectLinesState.NoIntersection;
        }
      }
 
      return result;
    }
 
    /// <summary>
    /// Given a vector going from L1 to L2, get the projected
    /// distance of point P from the vector.
    /// If distance is positive, the point is on the right side
    /// of the vector, if distance is negative, the point is on
    /// the left side of the vector.
    /// Function assume all points lay on the same plane
    /// </summary>
    /// <param name="l1">Vector origin</param>
    /// <param name="l2">Vector direction</param>
    /// <param name="p">Point to get distance from</param>
    /// <returns>Projected distance of P from vector L1->L2</returns>
 
    public static Double DistFromLine(
      Point3d l1, Point3d l2, Point3d p
    )
    {
      csCosDir c = new csCosDir(l1, l2);
 
      return (((p.Y - l1.Y) * c.cx) - ((p.X - l1.X) * c.cy));
    }
 
    /// <summary>
    /// Get bisetrix coefficients of two vectors.
    /// Vectors are provided as coefficients and the order must
    /// be given in counterclockwise order.
    /// This is a 2d computation, vectors must lay on the same plane
    /// </summary>
    /// <param name="r1">First vector</param>
    /// <param name="r2">Second vector</param>
    /// <param name="rb">[out]Resulting coefficients</param>
    /// <returns>True if bisetrix has been found, false if not
    /// (parallel vectors?)</returns>
 
    public static bool FindBisect(
      csCosDir r1, csCosDir r2, ref csCosDir rb
    )
    {
      bool result = true;
 
      // Coefficients may be considered as points of a limited
      // space that goes from -1 to 1
      // Origin 0,0 is the intersection of the two vectors and
      // origin of the bisetrix
 
      // Quick check for vectors (almost) co-linear
 
      Double diste =
        Math.Sqrt(
          (r2.cx - r1.cx) * (r2.cx - r1.cx) +
          (r2.cy - r1.cy) * (r2.cy - r1.cy)
        );
      if (diste < csMath.dEpsilon)
      {
        // Vectors have very similar coefficients, use alternate
        // algorithm for a borderline situation
 
        Double dcx = (r2.cx + r1.cx) * 0.5;
        Double dcy = (r2.cy + r1.cy) * 0.5;
        Double dd = Math.Sqrt(dcx * dcx + dcy * dcy);
 
        if (dd < csMath.dEpsilon)
        {
          // Really same coefficients, could be co-linear or
          // parallel but cannot say because we don't have
          // points on segments, just direction
 
          result = false;
        }
        else
        {
          // Denominator valid, use point distance from vector
          // to get position of the first vector
 
          Double distc =
            r1.cx * (r2.cy - r1.cy) - r1.cy * (r2.cx - r1.cx);
          Double dSign = (distc < 0) ? -1.0 : 1.0;
 
          rb.cx = dSign * dcx / dd;
          rb.cy = dSign * dcy / dd;
        }
      }
      else
      {
        // Vectors normally spaced, use simpler formula
 
        Double dcx = (r2.cx - r1.cx);
        Double dcy = (r2.cy - r1.cy);
        Double dd = Math.Sqrt(dcx * dcx + dcy * dcy);
 
        rb.cx = dcy / dd;
        rb.cy = -dcx / dd;
      }
 
      return result;
    }
  }
}

Before we show how the code works, let’s start by drawing the type of polyline the code will control:

Here are its standard grips:

When we run the GOO command to toggle our overrule on and redisplay the grips, here’s what we see:

And here’s what happens when we manipulate one of the “corners” via its grip:

You can see how the overrule maintains the coherence of the overall polyline as you move the grip. Very cool stuff.

Thanks again for sharing this, Massimo! :-)

Posted at 06:49 AM in AutoCAD, AutoCAD .NET, Geometry, Graphics system, Overrules | Permalink | Comments (4)

February 08, 2012

My First AutoCAD Plug-In

Hot on the heels of the Revit and Inventor installments in this series of guides (OK, OK – perhaps not exactly hot, but then “warm on the heels” doesn’t have quite the same ring to it ;-), I’m happy to announce that the previously mentioned “My First AutoCAD Plug-in” guide is now available.

Stephen Preston, the author of this excellent guide, has done a great job of creating a compelling sample – which keeps your block attributes horizontal, irrespective of the block rotation – and a series of straightforward explanations to help power-users and programming “newbies” take the plunge into the world of AutoCAD programming.

Here’s a quick video introducing the guide:

You can access this (so far still expanding) series of guides via autodesk.com/myfirstplugin.

Posted at 05:59 AM in AutoCAD, AutoCAD .NET, Overrules, Training | Permalink | Comments (1)

December 09, 2011

Adding an ObjectOverrule to stop AutoCAD objects from being erased using .NET

As a follow-on from the last post, today we’re going to see how to actually stop the erase operation from happening for a certain type of object (in this case we’re going to focus on Lines). Thanks for Stephen Preston for showing us the way in his comment on that post: inspired by his suggestion I ended up coding this before breakfast (although I do recommend taking care when throwing exceptions on an empty stomach ;-).

Here’s the C# code implementing the PER (Prevent Erasure) command:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
 
namespace WeLikeToBlock
{
  public class Commands
  {
    public class EraseOverrule : ObjectOverrule
    {
      public override void Erase(DBObject dbObject, bool erasing)
      {
        base.Erase(dbObject, erasing);
 
        throw new
          Autodesk.AutoCAD.Runtime.Exception(
            ErrorStatus.NotApplicable
          );
      }
    }
 
    static EraseOverrule _theOverrule = null;
 
    [CommandMethod("PER")]
    static public void PreventErase()
    {
      Editor ed =
        Application.DocumentManager.MdiActiveDocument.Editor;
 
      if (_theOverrule == null)
      {
        _theOverrule = new EraseOverrule();
 
        ObjectOverrule.AddOverrule(
          RXObject.GetClass(typeof(Line)),
          _theOverrule,
          false
        );
 
        ObjectOverrule.Overruling = true;
 
        ed.WriteMessage("\nPreventing erasure of lines.");
      }
      else
      {
        ObjectOverrule.RemoveOverrule(
          RXObject.GetClass(typeof(Line)),
          _theOverrule
        );
 
        _theOverrule.Dispose();
        _theOverrule = null;
 
        ed.WriteMessage("\nNo longer preventing erasure of lines.");
      }
    }
  }
}

The original reason I started investigating this topic was a discussion group post where someone was trying to stop certain blocks from being redefined. Based on the approach of throwing exceptions, I revisited the idea of blocking certain block table records from being opened for write. While it stopped the redefinition from happening, it did (unsurprisingly) cause AutoCAD to crash, which is also why such a technique – while powerful – should be used with extreme caution (hence my comment in the last post describing the act of blocking Erase as being contentious or potentially disastrous). Certain code paths may not be ready for low-level operations within AutoCAD being blocked arbitrarily, especially operations such as opening symbol table records.

There may yet be a simple way to stop block redefinition – if I end up finding a way, I’ll certainly post it here.

Posted at 05:15 AM in AutoCAD, AutoCAD .NET, Notification / Events, Overrules | Permalink | Comments (3)

December 07, 2011

Adding an ObjectOverrule to watch for erasure of AutoCAD objects using .NET

I started looking into the ObjectOverrule class, this week, to see if I could use it to prevent erasure of certain objects. My thinking was that overruling Erase() would allow me to control whether an object was erased or not, simply by my decision whether or not to super-message to the base implementation.

That doesn’t appear to be the case, as whether I call the base implementation or not the object gets erased. I’ll have to confirm that this is expected behaviour, but in the meantime I thought I’d share a version of my code which adds a simple ObjectOverrule to watch for erasure/unerasure of database objects in AutoCAD. It’s not very different from using tools such as ArxDbg/MgdDbg/EventsWatcher to watch for Database.ObjectErased() – it just uses an overrule to do something very similar.

Here’s the C# code to add a command to watch for erasure (WER):

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
 
namespace WeLikeToWatch
{
  public class Commands
  {
    public class EraseOverrule : ObjectOverrule
    {
      public override void Erase(DBObject dbObject, bool erasing)
      {
        base.Erase(dbObject, erasing);
 
        Application.DocumentManager.MdiActiveDocument.Editor.
          WriteMessage(
            "\n{0} {1} ({2}).",
            erasing ? "Erasing" : "Unerasing",
            dbObject.GetType().Name,
            dbObject.Handle
          );
      }
    }
 
    static EraseOverrule _theOverrule = null;
 
    [CommandMethod("WER")]
    static public void WatchErasure()
    {
      Editor ed =
        Application.DocumentManager.MdiActiveDocument.Editor;
 
      if (_theOverrule == null)
      {
        _theOverrule = new EraseOverrule();
 
        ObjectOverrule.AddOverrule(
          RXObject.GetClass(typeof(DBObject)),
          _theOverrule,
          false
        );
 
        ObjectOverrule.Overruling = true;
 
        ed.WriteMessage("\nWatching erasure of database objects.");
      }
      else
      {
        ObjectOverrule.RemoveOverrule(
          RXObject.GetClass(typeof(DBObject)),
          _theOverrule
        );
 
        _theOverrule.Dispose();
        _theOverrule = null;
 
        ed.WriteMessage(
          "\nNo longer watching erasure of database objects."
        );
      }
    }
  }
}

I’ll check in on the behaviour I’m seeing, to make sure my expectations are appropriate: I can see why arbitrarily stopping Erase() from being called on any object might be contentious (disastrous?), so it may simply be an “additive” event, rather than allowing outright prevention/replacement of the call.

In the meantime, try calling the WER command and performing some simple AutoCAD commands: you should find it interesting to see some of what’s going on under the hood.

The above code could clearly watch for other events available from ObjectOverrule, with very little effort:

Cancel
Close
DeepClone
Open
WblockClone

But that’s for another day. :-)

Posted at 05:05 PM in AutoCAD, AutoCAD .NET, Notification / Events, Overrules | Permalink | Comments (2)

September 02, 2010

September’s Plugin of the Month: DigSigStamp

Yesterday Scott Sheppard announced the availability of this plugin over on It’s Alive in the Lab.

We originally received a request for this Plugin of the Month some time ago. Fenton Webb, from our DevTech Americas team, developed the initial version using an ObjectARX custom entity – as the requester required support for versions of AutoCAD prior to 2010 – but for this public release, Stephen Preston went ahead and re-implemented the mechanism in a .NET application using the Overrules API introduced in AutoCAD 2010.

This plugin basically allows you to see graphically when an AutoCAD drawing is digitally signed, which is apparently a requirement for some branches of government. The idea is that you specify a couple of different block definitions to indicate what should be displayed when the drawing is signed and when it’s not. You then choose a particular block reference – which probably sits somewhere on your title sheet – to have it’s WorldDraw() display function overruled to display the appropriate block definition, depending on whether or not the drawing has been signed and has a valid signature attached. The “valid” block definition can contain attributes that get populated with information provided in the digital signature.

A number of fairly innocuous activities – such as panning and zooming – invalidate a drawing’s digital signature. While we choose to display the appropriate “invalid” block in the editor, when the drawing is plotted we do a little more work, to make sure the drawing gets plotted as “valid”.

I’m actually not going to post the code for this one to my blog (you can download it from the Labs site, of course). The plugin uses a few tricks to implement a relatively rudimentary security mechanism: if people need something more secure, they will need to invest some effort themselves. If we went the whole hog and implemented industrial-strength security for this plugin, we clearly wouldn’t be able to publish the source code. We therefore decided to leave it fairly lightweight and open for people to extend as they see fit. To benefit those people choosing to use the implementation as-is, I’ve left the implementation details in the source that comes along with the plugin.

Posted at 01:34 PM in AutoCAD, AutoCAD .NET, Blocks, Graphics system, Overrules, Plugin of the Month | Permalink | Comments (2)

May 31, 2010

June’s Plugin of the Month: Dimension Patrol

Thanks again to Stephen Preston, our DevTech Americas Manager, for developing this very useful little utility. You can find an earlier version of this code – which I’d converted to C# and extended to cover text entities – in this previous post.

June’s Plugin of the Month is now live: Dimension Patrol for AutoCAD. This one was kicked off by a suggestion from Shaan Hurley: a tool for designers and CAD Managers to quickly check drawings for dimensions with overridden text (which, logically enough, could mean the dimensions no longer accurately reflect their associated distance or value).

Sometimes the best applications are the simplest, and this one is certainly elegant in its simplicity. To be fair, though, it’s depending on the Overrule mechanism introduced in AutoCAD 2010 - hence the requirement to use AutoCAD 2010 or above – which provides you with a great deal of control over object behaviour.

Here are the important VB.NET source files from the project (which is, of course, provided with the plugin’s download from Labs).

Firstly the myPlugin.vb file:

Imports System
Imports Autodesk.AutoCAD.Runtime
Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.DatabaseServices
Imports Autodesk.AutoCAD.Geometry
Imports Autodesk.AutoCAD.EditorInput
 
' This line is not mandatory, but improves loading performance
 
<Assembly: ExtensionApplication(GetType(DimensionPatrol.MyPlugin))> 
 
Namespace DimensionPatrol
 
  ' This class is instantiated by AutoCAD once and kept alive for 
  '  the duration of the session. 
 
  Public Class MyPlugin
    Implements IExtensionApplication
 
    ' Declare member variables - note they are Shared 
    '  (don't require class instance to access them)
 
    Private Shared mOverrule As DimPatrolDrawOverrule
    Private Shared WithEvents mDocs As DocumentCollection
    Private Shared mOldOverruleState As Boolean
 
    Private Shared ReadOnly Property DimPatrolVal() As Short
      Get
        Return MyCommands.DimPatrolVal
      End Get
    End Property
 
    Private Shared ReadOnly Property DimPatrolColVal() As Short
      Get
        Return MyCommands.DimPatrolColVal
      End Get
    End Property
 
    ' Called by AutoCAD to initialize the addin. 
    ' This is where we setup our overrule.
 
    Public Sub Initialize() _
      Implements IExtensionApplication.Initialize
 
      Try
 
        ' Add demand loading info to registry
 
        DemandLoading.RegistryUpdate.RegisterForDemandLoading()
 
        ' Initialize 'withevents' variables to activate events
 
        mDocs = Application.DocumentManager
 
        ' Register overrule
 
        mOverrule = New DimPatrolDrawOverrule
        Overrule.AddOverrule(RXObject.GetClass(GetType(Dimension)), _
                            mOverrule, False)
        mOverrule.SetCustomFilter()
        mOldOverruleState = Overrule.Overruling
        Overrule.Overruling = True
 
        ' In case this app is loaded midway through a session, 
        '  we need to honor values of DimPatrol and DimPatrolColor 
        '  and setup the current document
 
        UpdateDoc(mDocs.MdiActiveDocument)
 
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
 
        CleanUp(ex)
 
      End Try
 
    End Sub
 
    ' Our addin only terminates when AutoCAD quits - 
    '  you can't dynamically unload .NET DLLs.
    ' (So one could argue that this tidy up is unnecessary).
 
    Public Sub Terminate() Implements IExtensionApplication.Terminate
 
      CleanUp(Nothing)
 
    End Sub
 
    ' Tidy up our stuff (unregister overrules etc). 
    ' Called by Terminate method, and also in response to an
    '  exception to disable addin if there's a problem.
 
    Private Shared Sub CleanUp(ByVal ex As  _
                              Autodesk.AutoCAD.Runtime.Exception)
 
      ' If this is being called by an exception handler, 
      '  then we politely inform user of the problem.
 
      If Not ex Is Nothing Then
        MsgBox("Dimension Patrol has encountered an error and " & _
              "is disabling itself.", MsgBoxStyle.Critical, "Oops!")
      End If
 
      ' Deactivate event handlers
 
      mDocs = Nothing
 
      ' Unregister overrule
 
      If Not mOverrule Is Nothing Then
        Overrule.RemoveOverrule( _
          RXObject.GetClass(GetType(Dimension)), mOverrule)
      End If
 
      ' We assume here that no other addin that uses overrules was 
      '  loaded since our addin initialized.
 
      Overrule.Overruling = mOldOverruleState
 
    End Sub
 
 
    ' Called by  myCommands class to tell this class that value of 
    '  DimPatrolColor variable has changed.
    ' (That's why its a Friend method)
 
    Friend Shared Sub DimPatColorVar_Changed()
 
      Try
 
        Dim doc As Document = _
          Application.DocumentManager.MdiActiveDocument
 
        ' Set stored value of color for this document so we know 
        '  color change has been processed for this doc.
 
        Dim oldDimPatColVal As Short = _
          UpdateDocData(doc, "DimPatrolColor", DimPatrolColVal)
 
        ' Regen drawing if color has changed & DimPatrol sysvar = 1
        ' (Color changes while we're not drawing our custom graphics
        '  don't have any effect until DimPatrol is next changed and
        '  this doc is active/activated).
 
        If (DimPatrolVal) And (oldDimPatColVal <> DimPatrolColVal) _
          Then
          doc.Editor.Regen()
        End If
 
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
        CleanUp(ex)
      End Try
 
    End Sub
 
    ' Called by  myCommands class to tell this class that value of
    '  DimPatrolColor variable has changed
    ' (That's why its a Friend method)
 
    Friend Shared Sub DimPatVar_Changed()
 
      Try
 
        ' Update active document with new value of DimPatrol to show
        '  we've regened it since the value was last changed
 
        Dim doc As Document = _
          Application.DocumentManager.MdiActiveDocument
        UpdateDocData(doc, "DimPatrol", DimPatrolVal)
 
        ' Whatever else happens, if we've changed the value of 
        '  DimPatrol then we must regen the current document to 
        '  display changed graphics.
 
        doc.Editor.Regen()
 
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
        CleanUp(ex)
      End Try
 
    End Sub
 
 
    ' When user switches document we want to respond to possible 
    '  changes to DimPatrol and DimPatrolColor in that document
 
    Private Shared Sub mDocs_DocumentActivated(ByVal sender As _
      Object, ByVal e As Autodesk.AutoCAD.ApplicationServices. _
      DocumentCollectionEventArgs) Handles mDocs.DocumentActivated
 
      Try
 
        UpdateDoc(e.Document)
 
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
        CleanUp(ex)
      End Try
 
    End Sub
 
    ' Updates userdata key 'varName' in document 'doc' to value 'val'
    ' Returns old value (or 0 if there wasn't an old value)
 
    Private Shared Function UpdateDocData(ByVal doc As Document, _
      ByVal varName As String, ByVal val As Short) As Short
 
      Dim oldVal As Short
 
      If doc.UserData.ContainsKey(varName) Then
 
        ' Update value of key-value pair
 
        oldVal = doc.UserData.Item(varName)
        If oldVal <> val Then
          doc.UserData.Item(varName) = val
        End If
      Else
 
        ' Add key-value pair if it didn't exist
 
        doc.UserData.Add(varName, val)
        oldVal = 0
      End If
 
      Return oldVal
 
    End Function
 
 
    ' Check userdata attached to document (where we store value of 
    '  DimPatrol and DimPatrolColor when doc was last active). 
    ' If userdata isn't there, or if it differs from current values,
    '  then we must regen the drawing.
 
    Private Shared Sub UpdateDoc(ByVal doc As Document)
 
      ' Update old DimPatrol value to show changes to this doc have
      '  been processed
 
      Dim oldDimPatVal As Short = UpdateDocData(doc, "DimPatrol", _
                                                DimPatrolVal)
 
      ' Update old DimPatrolColor value to show changes to this doc
      '  have been processed
 
      Dim oldDimPatColVal As Short = UpdateDocData(doc, _
        "DimPatrolColor", DimPatrolColVal)
 
      ' If DimPatrol sysvar has changed, or DimPatrolColor has
      '  changed when DimPatrol = 1, then we must regen the drawing
 
      If (oldDimPatVal <> DimPatrolVal) Or ((DimPatrolVal) And _
        (oldDimPatColVal <> DimPatrolColVal)) Then
 
        doc.Editor.Regen()
      End If
 
    End Sub
  End Class
 
 
    ' This is the one and only overrule used by this utility
 
  Public Class DimPatrolDrawOverrule
    Inherits Autodesk.AutoCAD.GraphicsInterface.DrawableOverrule
 
    ' Overrule WorldDraw so we can draw our additional graphics 
    '  (solid color block covering the Dimension's extents)
 
    Public Overrides Function WorldDraw(ByVal drawable As  _
      Autodesk.AutoCAD.GraphicsInterface.Drawable, _
      ByVal wd As Autodesk.AutoCAD.GraphicsInterface.WorldDraw) _
      As Boolean
 
      Try
 
        ' We know this overrule is only registered for Dimensions,
        '  so we cast without checking. 
 
        Dim dm As Dimension = drawable
 
        ' Now we want to draw a colored box around Dimension's
        '  extents()
 
        Dim ext As Extents3d = dm.Bounds
        Dim maxPt As Point3d = ext.MaxPoint
        Dim minPt As Point3d = ext.MinPoint
        Dim pts As New Point3dCollection
 
        ' These are the vertices of the highlight box
 
        pts.Add(New Point3d(minPt.X, minPt.Y, minPt.Z))
        pts.Add(New Point3d(minPt.X, maxPt.Y, minPt.Z))
        pts.Add(New Point3d(maxPt.X, maxPt.Y, minPt.Z))
        pts.Add(New Point3d(maxPt.X, minPt.Y, minPt.Z))
 
        ' Store current filltype and set to FillAlways
 
        Dim oldFillType As  _
          Autodesk.AutoCAD.GraphicsInterface.FillType = _
          wd.SubEntityTraits.FillType
        wd.SubEntityTraits.FillType = _
          Autodesk.AutoCAD.GraphicsInterface.FillType.FillAlways
 
        ' Store old graphics color and set to the color we want
 
        Dim oldColor As Short = wd.SubEntityTraits.Color
        wd.SubEntityTraits.Color = MyCommands.DimPatrolColVal
 
        ' Draw the filled polygon
 
        wd.Geometry.Polygon(pts)
 
        ' Restore old settings
 
        wd.SubEntityTraits.FillType = oldFillType
        wd.SubEntityTraits.Color = oldColor
 
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
 
        ' Mop up any exception here so at least the Dimension can try 
        '  to draw itself
 
        Application.DocumentManager.MdiActiveDocument.Editor. _
        WriteMessage( _
          vbLf & "Error highlighting changed dimension: " _
          & ex.ErrorStatus.ToString & vbLf)
      End Try
 
      ' Let the overruled Drawable draw itself.
 
      Return MyBase.WorldDraw(drawable, wd)
 
    End Function
 
    ' This function is called if we call SetCustomFilter on our
    '  overrule to check if the overrule should be applied for each
    ' entity.
    ' We add our own code to return true if the Dimension passed in
    '  is one we want to highlight.
 
    Public Overrides Function IsApplicable( _
      ByVal overruledSubject As RXObject) As Boolean
 
      Try
 
        ' If its a Dimension, we check if the text has been manually
        '  changed. But only if DimPatrol sysvar is set to 1
 
        If (MyCommands.DimPatrolVal) And _
          (TypeOf overruledSubject Is Dimension) Then
 
          Dim dm As Dimension = overruledSubject
          If dm.DimensionText <> "" Then
            Return True
          End If
        End If
 
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
 
        ' Mop up any exception here so at least the Dimension can try
        '  to draw itself
 
        Application.DocumentManager.MdiActiveDocument.Editor. _
        WriteMessage(vbLf & "Error testing dimension: " _
                    & ex.ErrorStatus.ToString & vbLf)
      End Try
 
      ' We only get to here if object isn't a Dimension and it didn't
      '  contain overridden text
 
      Return False
 
    End Function
 
  End Class
 
End Namespace

And secondly the myCommands.vb file:

Imports System
Imports Autodesk.AutoCAD.Runtime
Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.DatabaseServices
Imports Autodesk.AutoCAD.Geometry
Imports Autodesk.AutoCAD.EditorInput
 
' This line is not mandatory, but improves loading performance
 
<Assembly: CommandClass(GetType(DimensionPatrol.MyCommands))> 
 
Namespace DimensionPatrol
 
  ' Container class for our commands
  ' All methods and properties in this class are Shared, 
  '  so this class is never instantiated by AutoCAD.
 
  Public Class MyCommands
 
    ' Member variables to store values of DIMPATROL and
    ' DIMPATROLCOLOR
 
    Private Shared mDimPatrol As Short = 0
    Private Shared mDimPatrolColor As Short = 1
 
    ' This property is also used by MyPlugin and
    ' DimPatrolDrawOverrule - hence use of 'Friend'
 
    Friend Shared Property DimPatrolVal() As Short
 
      Get
        Return mDimPatrol
      End Get
 
      Private Set(ByVal value As Short)
 
        mDimPatrol = value
 
        ' Tell MyPlugin that value of DimPatrol has changed
 
        MyPlugin.DimPatVar_Changed()
 
      End Set
 
    End Property
 
    ' This property is also used by MyPlugin and
    ' DimPatrolDrawOverrule - hence use of 'Friend'
 
    Friend Shared Property DimPatrolColVal() As Short
 
      Get
        Return mDimPatrolColor
      End Get
 
      Private Set(ByVal value As Short)
 
        mDimPatrolColor = value
 
        ' Tell MyPlugin that value of DimPatrolColor has changed
 
        MyPlugin.DimPatColorVar_Changed()
 
      End Set
 
    End Property
 
 
    ' Turn dimension patrol on (1) or off (0)
 
    <CommandMethod("ADNPLUGINS", "DIMPATROL", CommandFlags.Modal)> _
    Public Shared Sub DIMPATROL()
 
      Try
 
        ' Prompt for new value
 
        Dim ed As Editor
        ed = Application.DocumentManager.MdiActiveDocument.Editor
        Dim opts As New  _
          PromptIntegerOptions("Enter new value for DIMPATROL")
        opts.DefaultValue = DimPatrolVal
        opts.LowerLimit = 0
        opts.UpperLimit = 1
        Dim res As PromptIntegerResult = ed.GetInteger(opts)
 
        ' Only update stored value if user has entered a different
        '  value()
 
        If (res.Status = PromptStatus.OK) _
          And (res.Value <> DimPatrolVal) Then
 
          DimPatrolVal = res.Value
 
        End If
 
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
        Application.DocumentManager.MdiActiveDocument. _
          Editor.WriteMessage( _
            vbLf & "Error changing DIMPATROL value: " & _
            ex.ErrorStatus.ToString & vbLf)
      End Try
 
    End Sub
 
 
    ' Allow user to set highlight color for manually edited
    ' dimensions. Color index can be set within range 1-7.
 
    <CommandMethod("ADNPLUGINS", "DIMPATROLCOLOR", _
                  CommandFlags.Modal)> _
    Public Shared Sub DIMPATROLCOLOR()
 
      Try
 
        ' Prompt for new value
 
        Dim ed As Editor
        ed = Application.DocumentManager.MdiActiveDocument.Editor
        Dim opts As New  _
          PromptIntegerOptions("Enter new value for DIMPATROLCOLOR")
        opts.DefaultValue = DimPatrolColVal
        opts.LowerLimit = 1
        opts.UpperLimit = 7
        Dim res As PromptIntegerResult = ed.GetInteger(opts)
 
        ' Only update stored value if user has entered a different 
        '  value
 
        If (res.Status = PromptStatus.OK) _
          And (res.Value <> DimPatrolColVal) Then
 
          DimPatrolColVal = res.Value
 
        End If
 
      Catch ex As Autodesk.AutoCAD.Runtime.Exception
        Application.DocumentManager.MdiActiveDocument.Editor. _
          WriteMessage( _
            vbLf & "Error changing DIMPATROLCOLOR value: " _
            & ex.ErrorStatus.ToString & vbLf)
      End Try
 
    End Sub
 
 
    'Remove demand load settings from registry
 
    <CommandMethod("ADNPLUGINS", "REMOVEDP", CommandFlags.Modal)> _
    Public Shared Sub RemoveDP()
 
      DemandLoading.RegistryUpdate.UnregisterForDemandLoading()
 
      Dim ed As Editor = _
        Autodesk.AutoCAD.ApplicationServices.Application _
        .DocumentManager.MdiActiveDocument.Editor()
      ed.WriteMessage(vbCr + _
        "Dimension Patrol will not be loaded" _
        + " automatically in future editing sessions.")
 
    End Sub
 
  End Class
 
End Namespace

We can set the DIMPATROL value to 1 to turn on checking for problematic dimensions. Here’s are some problematic dimensions from an Xrefed drawing (which is why the red is slightly dimmed):

Posted at 03:09 PM in AutoCAD, AutoCAD .NET, Dimensions, Overrules, Plugin of the Month | Permalink | Comments (9)

March 19, 2010

Using overrules to highlight AutoCAD dimensions and text using .NET

Thanks to Stephen Preston for providing the prototype that I extended for this post. He put it together in response to a suggestion for a new Plugin of the Month from Shaan Hurley, who thought a “dimension finder” tool for locating overridden dimension text would be useful for people. This code may well develop into that tool, but for now it’s being posted in its current, admittedly still somewhat rough, state.

The below code implements a couple of overrules using the mechanism introduced in AutoCAD 2010: one to highlight dimensions in a drawing which have had their text manually overridden – potentially a big problem if they no longer reflect the actual size of the object being dimensioned, of course – and one to highlight the DBText and MText objects in a drawing. I was hoping to work out how to specifically highlight the text of an overridden dimension – effectively applying the text highlighting overrule to the dimension highlighting on – but I’m not there yet: getting back to the Dimension from the contained MText will take some work, and the weekend has already started.

So here’s the code “as is”, with the expectation that the technique will most likely evolve, over time.

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.GraphicsInterface;
using Autodesk.AutoCAD.Runtime;
using System;
 
namespace DimensionFinder
{
  public class Commands
  {      
    // Stores our global overrules instance
 
    private static DimensionHighlightOverrule _dho = null;
    private static TextHighlightOverrule _tho = null;
 
    // Highlights the dimensions in the drawing
    // with overridden text
 
    [CommandMethod("SHOWDIMS")]
    public static void ShowDimensions()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
 
      if (_dho == null)
      {
        _dho = new DimensionHighlightOverrule(3);
        _dho.SetCustomFilter();
      }
      short newCol =
        UpdateHighlightOverrule(
          doc, _dho, new Type[] {typeof(Dimension)}
        );
      if (newCol < 0)
      {
        _dho.Dispose();
        _dho = null;
      }
      else
        _dho.HighlightColor = newCol;
    }
 
    // Highlights the text objects in the drawing
 
    [CommandMethod("SHOWTEXT")]
    public static void ShowText()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
 
      if (_tho == null)
        _tho = new TextHighlightOverrule(1);
 
      short newCol =
        UpdateHighlightOverrule(
          doc, _tho, new Type[] {typeof(DBText), typeof(MText)}
        );
      if (newCol < 0)
      {
        _tho.Dispose();
        _tho = null;
      }
      else
        _tho.HighlightColor = newCol;
    }
 
    // A shared function which applies our highlight overrule
    // to different types, adjusting the color index used
 
    private static short UpdateHighlightOverrule(
      Document doc, HighlightOverrule ho, Type[] entTypes
    )
    {
      // Ask the user for the new color index to use
 
      PromptIntegerOptions opts =
        new PromptIntegerOptions("\nEnter highlight color index: ");
      opts.LowerLimit = 0;
      opts.UpperLimit = 127;
      opts.Keywords.Add("Clear");
      opts.DefaultValue = ho.HighlightColor;
 
      PromptIntegerResult res = doc.Editor.GetInteger(opts);
      if (res.Status == PromptStatus.Keyword)
      {
        // If the Clear keyword was entered, let's remove the
        // overrule
 
        if (res.StringResult == "Clear")
        {
          // Do so for each of our types
 
          foreach (Type t in entTypes)
          {
            // Use try-catch, as Overrule.HasOverrule() needs an
            // instance of an AutoCAD object, and we just have the
            // type
 
            try
            {
              Overrule.RemoveOverrule(RXObject.GetClass(t), ho);
            }
            catch
            { }
          }
          doc.Editor.Regen();
          return -1;
        }
      }
      else if (res.Status == PromptStatus.OK)
      {
        // Otherwise we attach the overrule for each type
 
        foreach (Type t in entTypes)
        {
          // Use try-catch, as Overrule.HasOverrule() needs an
          // instance of an AutoCAD object, and we just have the
          // type
 
          try
          {
            Overrule.AddOverrule(RXObject.GetClass(t), ho, false);
          }
          catch
          { }
        }
 
        // If requested highlight color is a new color, then we
        // want to change it
 
        if (ho.HighlightColor != res.Value)
          ho.HighlightColor = (short)res.Value;
 
        // Make sure overruling is switched on
 
        Overrule.Overruling = true;
        doc.Editor.Regen();
      }
      return (short)res.Value;
    }
  }
 
  // Custom base class with a highlight text property
 
  public class HighlightOverrule : DrawableOverrule
  {
    public HighlightOverrule(short defCol)
    {
      _color = defCol;
    }
 
    // Color index used to highlight
 
    private short _color;
 
    // The color we highlight blocks with
 
    public short HighlightColor
    {
      get { return _color; }
      set
      {
        if ((value >= 0) && (value <= 127))
        {
          _color = value;
        }
      }
    }
  }
 
  // Overrule to highlight dimensions
 
  public class DimensionHighlightOverrule : HighlightOverrule
  {
    public DimensionHighlightOverrule(short defCol) : base(defCol)
    {
    }
 
    public override bool WorldDraw(Drawable drawable, WorldDraw wd)
    {
      // We know this overrule is only registered for Dimensions,
      // so could risk a cast without checking 
 
      Dimension dm = drawable as Dimension;
      if (dm != null)
      {
        // Now we want to draw a box around the Dimension's extents
 
        Extents3d? ext = dm.Bounds;
        if (ext.HasValue)
        {
          Point3d maxPt = ext.Value.MaxPoint;
          Point3d minPt = ext.Value.MinPoint;
 
          // These are the vertices of the highlight box
 
          Point3dCollection pts = new Point3dCollection();
          pts.Add(new Point3d(minPt.X, minPt.Y, minPt.Z));
          pts.Add(new Point3d(minPt.X, maxPt.Y, minPt.Z));
          pts.Add(new Point3d(maxPt.X, maxPt.Y, minPt.Z));
          pts.Add(new Point3d(maxPt.X, minPt.Y, minPt.Z));
 
          // Store current filltype and set to FillAlways
 
          FillType oldFillType = wd.SubEntityTraits.FillType;
          wd.SubEntityTraits.FillType = FillType.FillAlways;
 
          // Store old graphics color and set to the color we want
 
          short oldColor = wd.SubEntityTraits.Color;
          wd.SubEntityTraits.Color = this.HighlightColor;
 
          // Draw the filled polygon
 
          wd.Geometry.Polygon(pts);
 
          // Restore old settings
 
          wd.SubEntityTraits.FillType = oldFillType;
          wd.SubEntityTraits.Color = oldColor;
        }
      }
 
      // Let the overruled Drawable draw itself
 
      return base.WorldDraw(drawable, wd);
    }
 
    // This function is called if we call SetCustomFilter
    // on our custom overrule.
    // We add our own code to return true if the Dimension passed
    // in is one we want to highlight.
 
    public override bool IsApplicable(RXObject overruledSubject)
    {
      // If it's a Dimension, we check if it has overridden text
 
      Dimension dm = overruledSubject as Dimension;
      if (dm != null)
      {
        // If it's overridden, we'll highlight it
 
        if (dm.DimensionText != "")
          return true;
      }
 
      // Only get to here if object isn't a Dimension and it
      // didn't contain overridden text
 
      return false;
    }
  }
 
  // Overrule to highlight text (MText and DBText objects)
 
  public class TextHighlightOverrule : HighlightOverrule
  {
    public TextHighlightOverrule(short defCol) : base(defCol)
    {
    }
 
    public override bool WorldDraw(Drawable drawable, WorldDraw wd)
    {
      // Registered for MText and DBText, so proceed cautiously
 
      Entity ent = drawable as Entity;
      if (ent != null)
      {
        MText mt = ent as MText;
        DBText dt = ent as DBText;
 
        if (mt != null || dt != null)
        {
          Vector3d norm = (mt == null ? dt.Normal : mt.Normal);
 
          // Now we want to draw a box around the extents
 
          Extents3d? ext = ent.Bounds;
          if (ext.HasValue)
          {
            Point3d maxPt = ext.Value.MaxPoint;
            Point3d minPt = ext.Value.MinPoint;
 
            // These are the vertices of the highlight box
            // (it also contains a cross, for fun)
 
            Point3dCollection pts = new Point3dCollection();
            pts.Add(new Point3d(minPt.X, minPt.Y, minPt.Z));
            pts.Add(new Point3d(minPt.X, maxPt.Y, minPt.Z));
            pts.Add(new Point3d(maxPt.X, minPt.Y, minPt.Z));
            pts.Add(new Point3d(maxPt.X, maxPt.Y, minPt.Z));
            pts.Add(new Point3d(minPt.X, minPt.Y, minPt.Z));
            pts.Add(new Point3d(maxPt.X, minPt.Y, minPt.Z));
            pts.Add(new Point3d(maxPt.X, maxPt.Y, minPt.Z));
            pts.Add(new Point3d(minPt.X, maxPt.Y, minPt.Z));
 
            // Store current filltype and set to FillNever
 
            FillType oldFillType = wd.SubEntityTraits.FillType;
            wd.SubEntityTraits.FillType = FillType.FillNever;
 
            // Store old graphics color and set to the color we want
 
            short oldColor = wd.SubEntityTraits.Color;
            wd.SubEntityTraits.Color = this.HighlightColor;
 
            // Draw the polyline
 
            wd.Geometry.Polyline(pts, norm, IntPtr.Zero);
 
            // Restore old settings
 
            wd.SubEntityTraits.FillType = oldFillType;
            wd.SubEntityTraits.Color = oldColor;
          }
        }
      }
 
      // Let the overruled Drawable draw itself.
 
      return base.WorldDraw(drawable, wd);
    }
  }
}

To see it in action, let’s create some dimensions with overridden text (the two on the right, clearly :-):

When we run the SHOWDIMS command, selecting the default colour index, we see them get highlighted:

And if we run the SHOWTEXT command, doing the same, we see the text gets further highlighted:

Bear in mind there’s still some work to be done to get the code working properly in MDI, etc. Even so, it seemed worth posting in its current state, as I’m sure the technique will prove useful to someone, and once again highlights how cool the new Overrule API is.

I’m now heading off on a two-week trip around Asia, so we’ll see if I get the chance to take this further during that time.

Posted at 10:06 PM in AutoCAD, Dimensions, Graphics system, Overrules | Permalink | Comments (8)

August 31, 2009

Gluing a point to an AutoCAD curve using overrules from .NET – Part 3

In the most recent part of this series, we looked at one possible mechanism to allow points to be moved along a network of curves, extending the first part in this series, which focused on the case of a point on a single curve.

This post is going to focus on something slightly different: it’s going to look at making the points added to a particular curve be associative to that curve – i.e. travel along with it as the curve is moved – and in the process we’re going to adjust the way we link between our objects, by moving the information into an object’s Extended Entity Data (XData). This does a few things: firstly it breaks our network-related technique (never fear – we’ll be able to get it back, in due course :-) by removing the idea of a central list of curves. It also allows us to have points that are connected to curves, and points that are not (which is clearly desirable). It also lays a more solid foundation for other operations, such as erasing the points on a curve when the curve itself is erased. All good stuff.

Just to be clear: there are lots of ways ways to approach this problem – this is just another possible mechanism – so you might be interested in checking out this previous series, which addressed a similar problem a little differently.

For now let’s see this basic implementation of our XData-related code. 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;
 
namespace PointOnCurveTest
{
  public class LinkApplication
  {
    static string regAppName = "TTIF_PTS";
 
    public class LinkTransOverrule : TransformOverrule
    {
      static bool _transforming = false;
 
      // A static pointer to our overrule instance
 
      static public LinkTransOverrule theOverrule =
        new LinkTransOverrule();
 
      // A flag to indicate whether we're overruling
 
      static private bool overruling = false;
 
      // Our overrule should only be applied to objects
      // carrying our XData
 
      public LinkTransOverrule()
      {
        SetXDataFilter(regAppName);
      }
 
      // Turn on the transform overrule if it isn't already
 
      public static void TurnOn()
      {
        if (!overruling)
        {
          ObjectOverrule.AddOverrule(
            RXClass.GetClass(typeof(Entity)),
            LinkTransOverrule.theOverrule,
            true
          );
          overruling = true;
          TransformOverrule.Overruling = true;
        }
      }
 
      // Turn off the transform overrule if it's on
 
      public static void TurnOff()
      {
        if (overruling)
        {
          ObjectOverrule.RemoveOverrule(
            RXClass.GetClass(typeof(Entity)),
            LinkTransOverrule.theOverrule
          );
          overruling = false;
          TransformOverrule.Overruling = false;
        }
      }
 
      // Our primary overruled function
 
      public override void TransformBy(Entity e, Matrix3d mat)
      {
        // If we're already transforming, don't re-enter, just
        // super-message to the base
 
        if (_transforming)
          base.TransformBy(e, mat);
        else
        {
          Database db = HostApplicationServices.WorkingDatabase;
 
          // Otherwise get our linked objects: check whether
          // there are any
 
          ObjectIdCollection ids = GetLinkedObjects(e);
          if (ids.Count > 0)
          {
            // If we're dealing with a point...
 
            DBPoint pt = e as DBPoint;
            if (pt != null)
            {
              // Work through the curves to find the closest to our
              // transformed point
 
              double min = 0.0;
              Point3d bestPt = Point3d.Origin;
              bool first = true;
              ObjectId bestId = ObjectId.Null;
 
              // We're using an Open/Close transaction, to avoid
              // problems with us using transactions in an event
              // handler
 
              OpenCloseTransaction tr =
                db.TransactionManager.StartOpenCloseTransaction();
              using (tr)
              {
                // For now linked objects can be curves, else
                // they'll be ignored
 
                Curve cur;
                foreach (ObjectId curId in ids)
                {
                  DBObject obj =
                    tr.GetObject(curId, OpenMode.ForRead, true);
 
                  // If our linked object was erased, remove it
                  // from this object's links
 
                  if (obj.IsErased)
                  {
                    RemoveLinkedObject(e, curId);
                  }
                  else
                  {
                    // Otherwise we get the closest point on it
                    // to our point, to compare with others
 
                    cur = obj as Curve;
                    if (cur != null)
                    {
                      Point3d ptLoc =
                        pt.Position.TransformBy(mat);
                      Point3d ptOnCurve =
                        cur.GetClosestPointTo(ptLoc, false);
                      Vector3d dist = ptOnCurve - ptLoc;
 
                      if (first || dist.Length < min)
                      {
                        first = false;
                        min = dist.Length;
                        bestPt = ptOnCurve;
                        bestId = curId;
                      }
                    }
                  }
                }
 
                // If we didn't find a point, super-message
                // (will transform the point as normal)
 
                if (first)
                  base.TransformBy(e, mat);
                else
                  pt.Position = bestPt;
              }
            }
 
            if (e is Curve)
            {
              // Automatically super-message: we're not changing the
              // transform behaviour of the curve, only of the
              // linked objects
 
              base.TransformBy(e, mat);
 
              // Get each linked object and transform it along with
              // the "parent"
 
              OpenCloseTransaction tr =
                db.TransactionManager.StartOpenCloseTransaction();
              using (tr)
              {
                foreach (ObjectId id in ids)
                {
                  DBObject obj = tr.GetObject(id, OpenMode.ForWrite);
                  Entity ent = obj as Entity;
 
                  if (ent != null)
                  {
                    _transforming = true;
                    ent.TransformBy(mat);
                    _transforming = false;
                  }
                }
                tr.Commit();
              }
            }
          }
        }
      }
    }
 
    // Function to add a reference between one object and another
    // (stored in an object's XData)
 
    public static void AddLinkedObject(DBObject obj, ObjectId id)
    {
      Database db =
        HostApplicationServices.WorkingDatabase;
 
      // First we need to make sure our application name is
      // in the Registered Application Table
 
      OpenCloseTransaction tr =
        db.TransactionManager.StartOpenCloseTransaction();
      using (tr)
      {
        RegAppTable rat =
          (RegAppTable)tr.GetObject(
            db.RegAppTableId, OpenMode.ForRead
          );
        if (!rat.Has(regAppName))
        {
          rat.UpgradeOpen();
          RegAppTableRecord ratr =
            new RegAppTableRecord();
          ratr.Name = regAppName;
          tr.AddNewlyCreatedDBObject(ratr, true);
          rat.Add(ratr);
        }
        tr.Commit();
      }
 
      // Get our object's current XData
 
      ResultBuffer rb = obj.XData;
 
      // Check the XData, to see whether our link already exists
 
      bool foundLink = false;
 
      if (rb != null)
      {
        bool foundStart = false;
 
        foreach (TypedValue tv in rb)
        {
          // The first TypedValue is our application name
 
          if (tv.TypeCode ==
              (int)DxfCode.ExtendedDataRegAppName &&
              tv.Value.ToString() == regAppName)
            foundStart = true;
          else
          {
            if (foundStart)
            {
              // Our links will all have the same code (1005)
 
              if (tv.TypeCode == (int)DxfCode.ExtendedDataHandle)
              {
                if (id.Handle.ToString() == tv.Value.ToString())
                  foundLink = true;
              }
            }
          }
        }
      }
 
      // If we didn't find the link, add it
 
      if (!foundLink)
      {
        // This is our link
 
        TypedValue tv2 =
          new TypedValue(
            (int)DxfCode.ExtendedDataHandle, id.Handle
          );
 
        // If there was no previous XData, create the ResultBuffer
 
        if (rb == null)
        {
          rb =
            new ResultBuffer(
              new TypedValue(
                (int)DxfCode.ExtendedDataRegAppName,
                regAppName
              ),
              tv2
            );
        }
        else
        {
          // Add our TypeValue to an existing ResultBuffer
 
          rb.Add(tv2);
        }
 
        // Set the XData on our object
 
        obj.XData = rb;
      }
      rb.Dispose();
    }
 
    // Function to remove a reference from one object to another
    // (stored in an object's XData)
 
    public static void RemoveLinkedObject(DBObject obj, ObjectId id)
    {
      // Get the existing XData
 
      ResultBuffer oldRb = obj.XData;
 
      // Create a ResultBuffer for the "filtered" XData
      // (will contain all the old links, except the one we want
      // to remove)
 
      ResultBuffer newRb =
        new ResultBuffer(
          new TypedValue(
            (int)DxfCode.ExtendedDataRegAppName,
            regAppName)
          );
 
      bool foundLink = false;
 
      if (oldRb != null)
      {
        bool foundStart = false;
 
        // Loop through the XData
 
        foreach (TypedValue tv in oldRb)
        {
          // The first TypedValue is our application name
 
          if (tv.TypeCode ==
              (int)DxfCode.ExtendedDataRegAppName &&
              tv.Value.ToString() == regAppName)
            foundStart = true;
          else
          {
            if (foundStart)
            {
              // Our links will all have the same code (1005)
 
              if (tv.TypeCode == (int)DxfCode.ExtendedDataHandle)
              {
                // If the link is not the one we want to remove,
                // add it to our list of XData to retain,
                // otherwise set a flag to say we found it
 
                if (id.Handle.ToString() != tv.Value.ToString())
                  newRb.Add(tv);
                else
                  foundLink = true;
              }
            }
          }
        }
      }
 
      // If we found the link (and therefore have XData to set)
      // change the object's XData
 
      if (foundLink)
        obj.XData = newRb;
 
      // Clean-up after ourselves
 
      oldRb.Dispose();
      newRb.Dispose();
    }
 
    // Function to retrieve the references from one object to another
    // (stored in an object's XData)
 
    public static ObjectIdCollection GetLinkedObjects(DBObject obj)
    {
      Database db =
        HostApplicationServices.WorkingDatabase;
 
      // Will return an ObjectIdCollection
 
      ObjectIdCollection ids = new ObjectIdCollection();
 
      // Get the object's XData
 
      using (ResultBuffer rb = obj.XData)
      {
        if (rb != null)
        {
          bool foundStart = false;
 
          foreach (TypedValue tv in rb)
          {
            // The first TypedValue is our application name
 
            if (tv.TypeCode ==
                (int)DxfCode.ExtendedDataRegAppName &&
                tv.Value.ToString() == regAppName)
              foundStart = true;
            else
            {
              if (foundStart)
              {
                // Our links will all have the same code (1005)
 
                if (tv.TypeCode == (int)DxfCode.ExtendedDataHandle)
                {
                  // Get the long integer from the string stored in
                  // our XData, and the Handle from the long
 
                  long lg =
                    System.Convert.ToInt64(tv.Value.ToString(), 16);
                  Handle hd = new Handle(lg);
 
                  // And then the ObjectId from the Handle
 
                  ObjectId id = db.GetObjectId(false, hd, -1);
 
                  // Add it to our list, if it isn't already in it
 
                  if (!ids.Contains(id))
                    ids.Add(id);
                }
              }
            }
          }
        }
      }
      return ids;
    }
 
    [CommandMethod("POC")]
    public void CreatePointOnCurve()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask the user to select a curve
 
      PromptEntityOptions opts =
      new PromptEntityOptions(
        "\nSelect curve at the point to create: "
      );
      opts.SetRejectMessage(
        "\nEntity must be a curve."
      );
      opts.AddAllowedClass(typeof(Curve), false);
 
      PromptEntityResult per = ed.GetEntity(opts);
 
      ObjectId curId = per.ObjectId;
      if (curId != ObjectId.Null)
      {
        // Let's make sure we'll be able to see our point
 
        db.Pdmode = 97;  // square with a circle
        db.Pdsize = -10; // relative to the viewport size
 
        Transaction tr =
          doc.TransactionManager.StartTransaction();
        using (tr)
        {
          DBObject obj =
            tr.GetObject(curId, OpenMode.ForRead);
          Curve cur = obj as Curve;
          if (cur != null)
          {
            // Our initial point should be the closest point
            // on the curve to the one picked
 
            Point3d pos =
              cur.GetClosestPointTo(per.PickedPoint, false);
            DBPoint pt = new DBPoint(pos);
 
            // Add it to the same space as the curve
 
            BlockTableRecord btr =
              (BlockTableRecord)tr.GetObject(
                cur.BlockId,
                OpenMode.ForWrite
              );
            ObjectId ptId = btr.AppendEntity(pt);
            AddLinkedObject(pt, curId);
            cur.UpgradeOpen();
            AddLinkedObject(cur, ptId);
            tr.AddNewlyCreatedDBObject(pt, true);
          }
          tr.Commit();
 
          LinkTransOverrule.TurnOn();
        }
      }
    }
  }
}

Some points to note about this implementation:

We now register the overrule to work for all entity types, but at the same time we tell AutoCAD to filter on our Register Application Name
- Only objects with our XData will cause the overrule to be called
Our TransformBy() function will therefore apply to all entities with our XData, although we’re only (currently) interested in DBPoints and Curves
- We do need to stop the function re-entering for the points we transform along with the parent curve, but that’s a simple matter of setting/checking a boolean flag
We have kept the technique of checking a number of curves, to see which is closest, but as we’re only adding the XData during the POC command – which currently only allows selection of a single curve – the behaviour is now once again similar to the first post in the series (although this is very easy to change)

Now let’s see what happens when our code is executed. We’ll take the same drawing as last time – which contains a Spline and a Polyline – and use the POC command to add a few points on each:

When we move the Spline, we see the points on it now move along with it:

What’s interesting is that when we do the same for a Polyline, the points don’t appear during the drag…

… but they do, indeed, show up in the right place once the Polyline has completed the move to its destination:

This is apparently due to optimization inside AutoCAD: during a recent discussion with our Engineering team I learned that during certain operations – such as when a modification to an object or set of objects can be represented by a standard transformation (such as scale, rotate or move) – AutoCAD captures the graphics of those objects and then performs a “sprite” optimization to move the object(s), rather than continually asking the object(s) to participate in the movement by drawing their own graphics or by transforming their internal state.

It’s not fully clear to me why this is happening in this particular situation – and with the Polyline rather than the Spline – but it does appear that this optimization has been turned on during the movement of the Polyline. This only occurs in very specific situations – such as in 3D rather than 2D – but it does seem something that would be valuable for applications to have more explicit control over.

That’s it for today’s post. I’m actually on vacation this week, but I do have something to share later in the week related to our “Plugin on the Month” initiative…

Posted at 11:27 PM in AutoCAD, AutoCAD .NET, Drawing structure, Geometry, Overrules | Permalink | Comments (2) | TrackBack (0)

August 26, 2009

Gluing a point to an AutoCAD curve using overrules from .NET – Part 2

In the last post we looked at some code to create a point on a curve, and make sure it stays on that curve when edited.

In this post we’re extending that code (albeit slightly) to work with a network of curves: the idea is that any curve which has a point created on it becomes a candidate for any point to snap onto as it moves around. This could clearly be extended to provided a better way of specifying the curves forming the network, of course.

Here’s the updated C# code, with the modified/new lines in red (the full source file is available 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 System.Collections.Generic;
    7 
    8 namespace PointOnCurveTest
    9 {
   10   public class PtTransOverrule : TransformOverrule
   11   {
   12     // A static pointer to our overrule instance
   13 
   14     static public PtTransOverrule theOverrule =
   15       new PtTransOverrule();
   16 
   17     // A list of the curves that have had points
   18     // attached to
   19 
   20     static internal List<ObjectId> _curves =
   21       new List<ObjectId>();
   22 
   23     // A flag to indicate whether we're overruling
   24 
   25     static bool overruling = false;
   26 
   27     public PtTransOverrule() { }
   28 
   29     // Out primary overruled function
   30 
   31     public override void TransformBy(Entity e, Matrix3d mat)
   32     {
   33       // We only care about points
   34 
   35       DBPoint pt = e as DBPoint;
   36       if (pt != null)
   37       {
   38         Database db = HostApplicationServices.WorkingDatabase;
   39 
   40         // Work through the curves to find the closest to our
   41         // transformed point
   42 
   43         double min = 0.0;
   44         Point3d bestPt = Point3d.Origin;
   45         bool first = true;
   46 
   47         // We're using an Open/Close transaction, to avoid
   48         // problems with us using transactions in an event
   49         // handler
   50 
   51         OpenCloseTransaction tr =
   52           db.TransactionManager.StartOpenCloseTransaction();
   53         using (tr)
   54         {
   55           foreach (ObjectId curId in _curves)
   56           {
   57             DBObject obj =
   58               tr.GetObject(curId, OpenMode.ForRead);
   59             Curve cur = obj as Curve;
   60             if (cur != null)
   61             {
   62               Point3d ptLoc =
   63                 pt.Position.TransformBy(mat);
   64               Point3d ptOnCurve =
   65                 cur.GetClosestPointTo(ptLoc, false);
   66               Vector3d dist = ptOnCurve - ptLoc;
   67 
   68               if (first || dist.Length < min)
   69               {
   70                 first = false;
   71                 min = dist.Length;
   72                 bestPt = ptOnCurve;
   73               }
   74             }
   75           }
   76           pt.Position = bestPt;
   77         }
   78       }
   79     }
   80 
   81     [CommandMethod("POC")]
   82     public void CreatePointOnCurve()
   83     {
   84       Document doc =
   85         Application.DocumentManager.MdiActiveDocument;
   86       Database db = doc.Database;
   87       Editor ed = doc.Editor;
   88 
   89       // Ask the user to select a curve
   90 
   91       PromptEntityOptions opts =
   92         new PromptEntityOptions(
   93           "\nSelect curve at the point to create: "
   94         );
   95       opts.SetRejectMessage(
   96         "\nEntity must be a curve."
   97       );
   98       opts.AddAllowedClass(typeof(Curve), false);
   99 
  100       PromptEntityResult per = ed.GetEntity(opts);
  101 
  102       ObjectId curId = per.ObjectId;
  103       if (curId != ObjectId.Null)
  104       {
  105         // Let's make sure we'll be able to see our point
  106 
  107         db.Pdmode = 97;  // square with a circle
  108         db.Pdsize = -10; // relative to the viewport size
  109 
  110         Transaction tr =
  111           doc.TransactionManager.StartTransaction();
  112         using (tr)
  113         {
  114           DBObject obj =
  115             tr.GetObject(curId, OpenMode.ForRead);
  116           Curve cur = obj as Curve;
  117           if (cur != null)
  118           {
  119             // Our initial point should be the closest point
  120             // on the curve to the one picked
  121 
  122             Point3d pos =
  123               cur.GetClosestPointTo(per.PickedPoint, false);
  124             DBPoint pt = new DBPoint(pos);
  125 
  126             // Add it to the same space as the curve
  127 
  128             BlockTableRecord btr =
  129               (BlockTableRecord)tr.GetObject(
  130                 cur.BlockId,
  131                 OpenMode.ForWrite
  132               );
  133             ObjectId ptId = btr.AppendEntity(pt);
  134             tr.AddNewlyCreatedDBObject(pt, true);
  135           }
  136           tr.Commit();
  137 
  138           // And add the curve to our central list
  139 
  140           _curves.Add(curId);
  141         }
  142 
  143         // Turn on the transform overrule if it isn't already
  144 
  145         if (!overruling)
  146         {
  147           ObjectOverrule.AddOverrule(
  148             RXClass.GetClass(typeof(DBPoint)),
  149             PtTransOverrule.theOverrule,
  150             true
  151           );
  152           overruling = true;
  153           TransformOverrule.Overruling = true;
  154         }
  155       }
  156     }
  157   }
  158 }

Now after having run our POC command to add points to a number of curves – effectively adding them to the “network” – we can grip-move a point, and should another curve in the network be closer, the point being edited will snap across to that one:

Posted at 10:52 PM in AutoCAD, AutoCAD .NET, Geometry, Notification / Events, Overrules | Permalink | Comments (1) | TrackBack (0)

August 24, 2009

Gluing a point to an AutoCAD curve using overrules from .NET – Part 1

Over the weekend I put together a little prototype to prove a concept for an internal project I’m working on. The idea was to force a point onto a curve (meaning anything inheriting from Curve in AutoCAD, such as Arc, Circle, Ellipse, Leader, Line, Polyline, Polyline2d, Polyline3d, Ray, Spline, Xline…), so that when the point is moved it snaps onto the curve to which it’s assigned. The solution I’ve put together is far from being complete – which is partly why I’m planning on making this a series, so I can flesh it out a little further in further posts – but it does demonstrate a reasonable technique for addressing the requirement.

The approach I chose was to use a TransformOverrule to modify the standard AutoCAD point’s TransformBy() behaviour (see this previous post for some commentary on using a TransformOverrule vs. a GripOverrule). Our TransformOverrule stores a list of curves that have had points attached to them, and during TransformBy() we check each one to see which curve this point was on. We then get the transformed point (i.e. the one being chosen by the user) and from there we get the closest point on that curve, which becomes the point’s new location.

TransformBy() is a pretty handy operation to overrule: it’s used by grip-editing and by the MOVE command, so you know these operations will lead to your object’s positional integrity being maintained (direct modification of properties, such as via the Properties Palette, won’t lead to it being called, however, so it’s not enough if you need to maintain complete control).

Some comments on the choice of storing a list of curves rather than some other association between the point and the curve:

Storing a map between the point (via its ObjectId) and the curve wouldn’t work, as TransformBy() often has to work on a temporary copy of an object, rather than the object itself (and the copy’s ObjectId will therefore be Null).
- We might also have looked at an approach such as the one used previously in our GripOverrule.
It might be possible to attach data (perhaps XData) to the point identifying the curve it’s attached to, but this would need to be available on the temporary clone (and is something that I’d need to check works).
It’s possible that working through a list of curves, checking each one, could become perceptibly slow if working with huge sets of data, but at that point a more efficient spatial indexing technique could be adopted.
Using a list of curves also allows us to modify the implementation to allow a point to travel along a network of curves (we’ll go through this modification in a future post).
One drawback of this approach is that once we move the curve independently from the point, they become detached as the point is no longer on any of the curves. We’ve put a specific clause in to allow points not on curves to be moved, but it would also be good to have the point be transformed along with the curve, so they stay together (another potential future modification). In the meantime the user will have to move the point back onto the curve (using the NEAr object snap, to make sure it’s precise) for the overrule to work for it, again.

One last point: we’re not persisting the curve list, in any way, so don’t expect points to reattach to lines when a session is restarted (until the POC command is used to create further points on curves and therefore add the curves to the list of those being managed by our system).

OK, enough blather, let’s get on with looking at the C# code:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.Runtime;
using System.Collections.Generic;
 
namespace PointOnCurveTest
{
  public class PtTransOverrule : TransformOverrule
  {
    // A static pointer to our overrule instance
 
    static public PtTransOverrule theOverrule =
      new PtTransOverrule();
 
    // A list of the curves that have had points
    // attached to
 
    static internal List<ObjectId> _curves =
      new List<ObjectId>();
 
    // A flag to indicate whether we're overruling
 
    static bool overruling = false;
 
    public PtTransOverrule() {}
 
    // Out primary overruled function
 
    public override void TransformBy(Entity e, Matrix3d mat)
    {
      // We only care about points
 
      DBPoint pt = e as DBPoint;
      if (pt != null)
      {
        Database db = HostApplicationServices.WorkingDatabase;
 
        // For each curve, let's check whether our point is on it
 
        bool found = false;
 
        // We're using an Open/Close transaction, to avoid problems
        // with us using transactions in an event handler
 
        OpenCloseTransaction tr =
          db.TransactionManager.StartOpenCloseTransaction();
        using (tr)
        {
          foreach (ObjectId curId in _curves)
          {
            DBObject obj = tr.GetObject(curId, OpenMode.ForRead);
            Curve cur = obj as Curve;
            if (cur != null)
            {
              Point3d ptOnCurve =
                cur.GetClosestPointTo(pt.Position, false);
              Vector3d dist = ptOnCurve - pt.Position;
              if (dist.IsZeroLength(Tolerance.Global))
              {
                Point3d pos =
                  cur.GetClosestPointTo(
                    pt.Position.TransformBy(mat),
                    false
                  );
                pt.Position = pos;
                found = true;
                break;
              }
            }
          }
          // If the point isn't on any curve, let the standard
          // TransformBy() do its thing
 
          if (!found)
          {
            base.TransformBy(e, mat);
          }
        }
      }
    }
 
    [CommandMethod("POC")]
    public void CreatePointOnCurve()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Database db = doc.Database;
      Editor ed = doc.Editor;
 
      // Ask the user to select a curve
 
      PromptEntityOptions opts =
        new PromptEntityOptions(
          "\nSelect curve at the point to create: "
        );
      opts.SetRejectMessage(
        "\nEntity must be a curve."
      );
      opts.AddAllowedClass(typeof(Curve), false);
 
      PromptEntityResult per = ed.GetEntity(opts);
 
      ObjectId curId = per.ObjectId;
      if (curId != ObjectId.Null)
      {
        // Let's make sure we'll be able to see our point
 
        db.Pdmode = 97;  // square with a circle
        db.Pdsize = -10; // relative to the viewport size
 
        Transaction tr =
          doc.TransactionManager.StartTransaction();
        using (tr)
        {
          DBObject obj =
            tr.GetObject(curId, OpenMode.ForRead);
          Curve cur = obj as Curve;
          if (cur != null)
          {
            // Out initial point should be the closest point
            // on the curve to the one picked
 
            Point3d pos =
              cur.GetClosestPointTo(per.PickedPoint, false);
            DBPoint pt = new DBPoint(pos);
 
            // Add it to the same space as the curve
 
            BlockTableRecord btr =
              (BlockTableRecord)tr.GetObject(
                cur.BlockId,
                OpenMode.ForWrite
              );
            ObjectId ptId = btr.AppendEntity(pt);
            tr.AddNewlyCreatedDBObject(pt, true);
          }
          tr.Commit();
 
          // And add the curve to our central list
 
          _curves.Add(curId);
        }
 
        // Turn on the transform overrule if it isn't already
 
        if (!overruling)
        {
          ObjectOverrule.AddOverrule(
            RXClass.GetClass(typeof(DBPoint)),
            PtTransOverrule.theOverrule,
            true
          );
          overruling = true;
          TransformOverrule.Overruling = true;
        }
      }
    }
  }
}

Now let’s see what happens when we run the POC command (for Point On Curve, but then it’s also a Proof Of Concept – geddit? :-).

The POC command will create a point at the selected location on a curve, at which point we can grip-edit it:

We can see that as we move the grip point around the drawing, the closest point to the attached curve is always used:

The point is always on the original curve, even if we try to select a point on another curve (even one that may be on the list of curves maintained by our PtTransOverrule class, if the POC command has been used on other curves):

That’s enough to get us started. Later in the week we’ll look at extending the code to create a stronger attachment between the point and the curve, but also to allow the point to travel along a network of curves. Fun, fun, fun! :-)

Posted at 10:28 AM in AutoCAD, AutoCAD .NET, Geometry, Notification / Events, Overrules | Permalink | Comments (1) | TrackBack (0)

Through the Interface

Kean Walmsley

June 2013

Post Index

Reverse Index

Autodesk Blogs