Through the Interface

// Use lightweight F# syntax

#light

// Declare a specific namespace and module name

module BounceHatch.Commands

// Import managed assemblies

#I @"C:\Program Files\Autodesk\AutoCAD 2008"

#I @".\PointInCurve\bin\Debug"

#r "acdbmgd.dll"

#r "acmgd.dll"

#R "PointInCurve.dll" // R = CopyFile is true

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open PointInCurve

// Get a random vector on a plane

let randomUnitVector pl =

  // Create our random number generator

  let ran = new System.Random()

  // First we get the absolute value

  // of our x and y coordinates

  let absx = ran.NextDouble()

  let absy = ran.NextDouble()

  // Then we negate them, half of the time

  let x = if (ran.NextDouble() < 0.5) then -absx else absx

  let y = if (ran.NextDouble() < 0.5) then -absy else absy

  // Create a 2D vector and return it as

  //  3D on our plane

  let v2 = new Vector2d(x, y)

  new Vector3d(pl, v2)

type traceType =

  | Accepted

  | Rejected

  | Superseded

// Draw one of three types of trace vector

let traceSegment (start:Point3d) (endpt:Point3d) trace =

  let ed =

    Application.DocumentManager.MdiActiveDocument.Editor

  let vecCol =

    match trace with

    | Accepted -> 3

    | Rejected -> 1

    | Superseded -> 2

  let trans =

    ed.CurrentUserCoordinateSystem.Inverse()

  ed.DrawVector

    (start.TransformBy(trans),

    endpt.TransformBy(trans),

    vecCol,

    false)

// Test a segment to make sure it is within our boundary

let testSegment cur (start:Point3d) (vec:Vector3d) =

  // (This is inefficient, but it's not a problem for

  //  this application. Some of the redundant overhead

  //  of firing rays for each iteration could be factored

  //  out, among other enhancements, I expect.)

  let pts =

    [for i in 1..10 -> start + (vec * 0.1 * Int32.to_float i)]

  // Call into our IsInsideCurve library function,

  // "and"-ing the results

  let inside pt =

    PointInCurve.Fns.IsInsideCurve(cur, pt)

  List.for_all inside pts

// For a particular boundary, get the next vertex on the

// curve, found by firing a ray in a random direction

let nextBoundaryPoint (cur:Curve)

    (start:Point3d) trace =

  // Get the intersection points until we

  // have at least 2 returned

  // (will usually happen straightaway)

  let rec getIntersect (cur:Curve)

    (start:Point3d) vec =

    let plane = cur.GetPlane()

    // Create and define our ray

    let ray = new Ray()

    ray.BasePoint <- start

    ray.UnitDir <- vec

    let pts = new Point3dCollection()

    cur.IntersectWith

      (ray,

      Intersect.OnBothOperands,

      pts,

      0, 0)

    ray.Dispose()

    if (pts.Count < 2) then

      let vec2 = randomUnitVector plane

      getIntersect cur start vec2

    else

      pts

  // For each of the intersection points - which

  // are points elsewhere on the boundary - let's

  // check to make sure we don't have to leave the

  // area to reach them

  let plane =

    cur.GetPlane()

  let pts =

    randomUnitVector plane |> getIntersect cur start

  // Get the distance between two points

  let getDist fst snd =

    let (vec:Vector3d) = fst - snd

    vec.Length

  // Compare two (dist, pt) tuples to allow sorting

  // based on the distance parameter

  let compDist fst snd =

    let (dist1, pt1) = fst

    let (dist2, pt2) = snd

    if dist1 = dist2 then

      0

    else if dist1 < dist2 then

      -1

    else // dist1 > dist2

      1

  // From the list of points we create a list

  // of (dist, pt) pairs, which we then sort

  let sorted =

    [ for pt in pts -> (getDist start pt, pt) ] |>

      List.sort compDist

  // A test function to check whether a segment

  // is within our boundary. It draws the appropriate

  // trace vectors, depending on success

  let testItem dist =

    let (distval, pt) = dist

    let vec = pt - start

    if (distval > Tolerance.Global.EqualVector) then

      if testSegment cur start vec then

        if trace then

          traceSegment start pt traceType.Accepted

        Some(dist)

      else

        if trace then

          traceSegment start pt traceType.Rejected

        None

    else

      None

  // Get the first item - which means the shortest

  // non-zero segment, as the list is sorted on distance

  // - that satisifies our condition of being inside

  // the boundary

  let ret = List.first testItem sorted

  match ret with

  | Some(d,p) -> p

  | None -> failwith "Could not get point"

// We're using a different command name, so we can compare

[<CommandMethod("fb")>]

let bounceHatch() =

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let db = doc.Database

  let ed = doc.Editor

  // Get various bits of user input

  let getInput =

    let peo =

      new PromptEntityOptions

        ("\nSelect point on closed loop: ")

    let per = ed.GetEntity(peo)

    if per.Status <> PromptStatus.OK then

      None

    else

      let pio =

        new PromptIntegerOptions

          ("\nEnter number of segments: ")

      pio.DefaultValue <- 500

      let pir = ed.GetInteger(pio)

      if pir.Status <> PromptStatus.OK then

        None

      else

        let pko =

          new PromptKeywordOptions

            ("\nDisplay segment trace: ")

        pko.Keywords.Add("Yes")

        pko.Keywords.Add("No")

        pko.Keywords.Default <- "Yes"

        let pkr = ed.GetKeywords(pko)

        if pkr.Status <> PromptStatus.OK then

          None

        else

          Some

            (per.ObjectId,

            per.PickedPoint,

            pir.Value,

            pkr.StringResult.Contains("Yes"))

  match getInput with

  | None -> ignore()

  | Some(oid, picked, numBounces, doTrace) ->

    // Capture the start time for performance

    // measurement

    let starttime = System.DateTime.Now

    use tr =

      db.TransactionManager.StartTransaction()

    // Check the selected object - make sure it's

    // a closed loop (could do some more checks here)

    let obj =

      tr.GetObject(oid, OpenMode.ForRead)

    match obj with

    | 😕 Curve ->

      let cur = obj :?> Curve

      if cur.Closed then

        let latest =

          picked.

            TransformBy(ed.CurrentUserCoordinateSystem).

              OrthoProject(cur.GetPlane())

        // Create our polyline path, adding the

        // initial vertex

        let path = new Polyline()

        path.Normal <- cur.GetPlane().Normal

        path.AddVertexAt

          (0,

          latest.Convert2d(cur.GetPlane()),

          0.0, 0.0, 0.0)

        // A recursive function to get the points

        // for our path

        let rec definePath start times =

          if times <= 0 then

            []

          else

            try

              let pt =

                nextBoundaryPoint cur start doTrace

              (pt :: definePath pt (times-1))

            with exn ->

              if exn.Message = "Could not get point" then

                definePath start times

              else

                failwith exn.Message

        // Another recursive function to add the vertices

        // to the path

        let rec addVertices (path:Polyline)

          index (pts:Point3d list) =

          match pts with

          | [] -> []

          | a::[] ->

            path.AddVertexAt

              (index,

              a.Convert2d(cur.GetPlane()),

              0.0, 0.0, 0.0)

            []

          | a::b ->

            path.AddVertexAt

              (index,

              a.Convert2d(cur.GetPlane()),

              0.0, 0.0, 0.0)

            addVertices path (index+1) b

        // Plug our two functions together, ignoring

        // the results

        definePath picked numBounces |>

          addVertices path 1 |>

            ignore

        // Now we'll add our polyline to the drawing

        let bt =

            tr.GetObject

              (db.BlockTableId,

              OpenMode.ForRead) :?> BlockTable

        let btr =

            tr.GetObject

              (bt.[BlockTableRecord.ModelSpace],

              OpenMode.ForWrite) :?> BlockTableRecord

        // We need to transform the path polyline so

        // that it's over our boundary

        path.TransformBy

          (Matrix3d.Displacement

            (cur.StartPoint - Point3d.Origin))

        // Add our path to the modelspace

        btr.AppendEntity(path) |> ignore

        tr.AddNewlyCreatedDBObject(path, true)

        // Commit, whether we added a path or not.

        tr.Commit()

        // Print how much time has elapsed

        let elapsed =

          System.DateTime.op_Subtraction

            (System.DateTime.Now, starttime)

        ed.WriteMessage

          ("\nElapsed time: " + elapsed.ToString())

        // If we're tracing, pause for user input

        // before regenerating the graphics

        if doTrace then

          let pko =

            new PromptKeywordOptions

              ("\nPress return to clear trace vectors: ")

          pko.AllowNone <- true

          pko.AllowArbitraryInput <- true

          let pkr = ed.GetKeywords(pko)

          ed.Regen()

    | _ ->

      ed.WriteMessage("\nObject is not a curve.")