Through the Interface

using System.Diagnostics;

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Runtime;

 

namespace GeometryCreation

{

  public class Commands

  {

    [CommandMethod("LBC")]

    public static void LinesBetweenCurves()

    {

      var doc = Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

 

      // Ask the user to select a couple of curves

 

      var peo = new PromptEntityOptions("\nSelect first curve");

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

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

      var per = ed.GetEntity(peo);

      if (per.Status != PromptStatus.OK)

        return;

 

      var firstId = per.ObjectId;

 

      peo.Message = "\nSelect second curve";

      per = ed.GetEntity(peo);

      if (per.Status != PromptStatus.OK)

        return;

 

      var secondId = per.ObjectId;

 

      // We need to know how many lines to draw between the two

 

      var pio = new PromptIntegerOptions("\nNumber of lines");

      pio.AllowNegative = false;

      pio.AllowZero = false;

      var pir = ed.GetInteger(pio);

      if (pir.Status != PromptStatus.OK)

        return;

 

      int num = pir.Value;

 

      var pko =

        new PromptKeywordOptions(

          "\nReady to continue? (if not, lines will be " +

          "re-created in opposite direction along one curve)" +

          " [Yes/No]",

          "Yes No"

        );

      pko.Keywords.Default = "Yes";

 

      // We have an outer transaction where we access some data

      // about the curves - we're not writing, so will commit()

      // at the end even if the user cancels

 

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

      {

        var firstCur =

          tr.GetObject(firstId, OpenMode.ForRead) as Curve;< /p>

        var secondCur =

          tr.GetObject(secondId, OpenMode.ForRead) as Curve;

        if (firstCur == null || secondCur == null)

          return; // Shouldn't happen, we asked the user for Curves

 

        // We'll be adding the new lines to the current space

 

        var btr =

          (BlockTableRecord)tr.GetObject(

            db.CurrentSpaceId, OpenMode.ForWrite

          );

 

        // Parameterize the two curves once

        // (we'll loop through the second backwards in

        // case we reverse the order)

 

        var pc1 = ParameterizeCurve(firstCur, num);

        var pc2 = ParameterizeCurve(secondCur, num);

 

        // Let's throw in an assert to make sure the collections

        // have the same size (will create an obscure message,

        // which is why I don't usually do this)

 

        Debug.Assert(pc1.Count == pc2.Count);

 

        // Here we're going to loop, allowing the user to flip

        // backwards and forwards between a mode where we

        // parameterize the second curve in reverse

 

        bool reverseOne = false;

 

        while (true)

        {

          // Our inner transaction, which will keep track of our

          // new lines for us

 

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

          {

            // Loop across the size of the collection(s), creating

            // lines between the points in each

 

            for (int i = 0; i < num; i++)

            {

              var start = pc1[i];

              var end = reverseOne ? pc2[num - (i + 1)] : pc2[i];

              var ln = new Line(start, end);

              btr.AppendEntity(ln);

              tr2.AddNewlyCreatedDBObject(ln, true);

            }

 

            // We want the graphics updated before the transaction

            // terminates, as we want the user to make an informed

            // decision

 

            tr2.TransactionManager.QueueForGraphicsFlush();

 

            // Prompt whether we shoudl continue or loop

 

            var pr = ed.GetKeywords(pko);

            if (pr.Status != PromptStatus.OK)

              break; // This will abort the inner transaction

 

            // If "No" we'll loop after flipping the "reverse"

            // boolean

 

            if (pr.StringResult == "No")

            {

              reverseOne = !reverseOne;

            }

            else

            {

              // Only commit the inner transaction when we had a

              // "yes, let's continue" response

 

              tr2.Commit();

              break;

            }

          }

        }

        // Always commit the outer (read-only) transaction as it's

        // less expensive that aborting

 

        tr.Commit();

      }

    }

 

    // Helper function to gather a certain number of points along

    // a Curve

 

    private static Point3dCollection ParameterizeCurve(

      Curve c, int count

    )

    {

      var pc = new Point3dCollection();

 

      // Our increment should be based on the fact we'll include

      // points at both StartParam and EndParam (hence "count - 1")

 

      var pinc = (c.EndParam - c.StartParam) / (count - 1);

 

      // Loop along the parameter space

 

      for (double p = c.StartParam; p < c.EndParam; p += pinc)

      {

        pc.Add(c.GetPointAtParameter(p));

      }

 

      // This approach may include a point at EndParam (or within

      // tolerance) so we only add EndParam explicitly if we are

      // one point short of what was requested

 

      if (pc.Count < count)

      {

        pc.Add(c.GetPointAtParameter(c.EndParam));

      }

      return pc;

    }

  }

}