Through the Interface

Parallelized pixelization inside AutoCAD using F#

As promised in the last post, we're now going to look at how to change the code to make the colour averaging routine work in parallel. The overall performance is marginally better on my dual-core machine, but I fully expect it to get quicker and quicker as the number of cores multiply.

To start with, though, here's the modified "synchronous" version of the code - as I went through making the code work in parallel, I noticed a bunch of general enhancements that were applicable to both versions. Here's the updated F# code:

// Use lightweight F# syntax

 

#light

 

// Declare a specific namespace and module name

 

module SyncPixelizer.Commands

 

// Import managed assemblies

 

#nowarn "9" // ... because we're using NativePtr

 

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open Autodesk.AutoCAD.Colors

open System.Drawing.Imaging

open Microsoft.FSharp.NativeInterop

 

// Add up the RGB values of a list of pixels

 

// We use a recursive function with an accumulator argument,

// (rt, gt, bt), to allow tail call optimization

 

let rec sumColors (pix : List<(byte*byte*byte)>) (rt,gt,bt) =

  match pix with

    | [] -> (rt, gt, bt)

    | (r, g, b) :: tl ->

        sumColors tl

          (rt + Byte.to_int r,

          gt + Byte.to_int g,

          bt + Byte.to_int b)

 

// Average out the RGB values of a list of pixels

 

let getAverageColour (pixels : List<(byte*byte*byte)>) =

  let (rsum, gsum, bsum) =

    sumColors pixels (0, 0, 0)

  let count = pixels.Length

  let ravg = Byte.of_int (rsum / count)

  let gavg = Byte.of_int (gsum / count)

  let bavg = Byte.of_int (bsum / count)

 

  // For some reason the pixel needs ro be reversed - probably

  // because of the bitmap format (needs investigation)

 

  Color.FromRgb(bavg, gavg, ravg)

 

// Function to get an index into our flat array

// from an x,y pair

 

let getIndexFromXY ysize x y =

  (x * ysize) + y

 

//  Get a chunk of pixels to average from one row

 

// We use a recursive function with an accumulator argument

// to allow tail call optimization

 

let rec getChunkRowPixels p xsamp acc =

  if xsamp = 0 then

    acc

  else

    let pix =

      [(NativePtr.get p 0,

        NativePtr.get p 1,

        NativePtr.get p 2)]

    let p = NativePtr.add p 3 // We do *not* mutate here

    getChunkRowPixels p (xsamp-1) (pix @ acc)

 

// Get a chunk of pixels to average from multiple rows

 

// We use a recursive function with an accumulator argument

// to allow tail call optimization

 

let rec getChunkPixels p stride xsamp ysamp acc =

  if ysamp = 0 then

    acc

  else

    let pix = getChunkRowPixels p xsamp []

    let p = NativePtr.add p stride  // We do *not* mutate here

    getChunkPixels p stride xsamp (ysamp-1) (pix @ acc)

 

// Get the various chunks of pixels to average across

// a complete bitmap image

 

let pixelizeBitmap (image:System.Drawing.Bitmap) xsize ysize =

 

  // Create a 1-dimensional array of pixel lists (one list,

  // which then needs averaging, per final pixel)

 

  let (arr : List<(byte*byte*byte)>[]) =

    Array.create (xsize * ysize) []

 

  // Lock the entire memory block related to our image

 

  let bd =

    image.LockBits

      (System.Drawing.Rectangle

        (0, 0, image.Width ,image.Height),

      ImageLockMode.ReadOnly, image.PixelFormat)

 

  // Establish the number of pixels to sample per chunk

  // in each of the x and y directions

 

  let xsamp = image.Width / xsize

  let ysamp = image.Height / ysize

 

  // We have a mutable pointer to step through the image

 

  let mutable (p:nativeptr<byte>) =

    NativePtr.of_nativeint (bd.Scan0)

 

  // Loop through the various chunks

 

  for i = 0 to ysize - 1 do

 

    // We take a copy of the current value of p, as we

    // don't want to mutate p while extracting the pixels

    // within a row

 

    let mutable xp = p

    for j = 0 to xsize - 1 do

 

      // Get the square chunk of pixels starting at

      // this x,y position

 

      let chk =

        getChunkPixels xp bd.Stride xsamp ysamp []

 

      // Add it into our array

 

      let idx = getIndexFromXY ysize j (ysize-1-i)

      arr.[idx] <- chk

 

      // Mutate the pointer to move along to the right

      // by a value of 3 (our RGB value) times the

      // number of pixels we're sampling in x

 

      xp <- NativePtr.add xp (xsamp * 3)

    done

 

    // Mutate the original p pointer to move on one row

 

    p <- NativePtr.add p (bd.Stride * ysamp)

  done

 

  // Finally unlock the bitmap data and return the array

 

  image.UnlockBits(bd)

  arr

 

// Create an array of ObjectIds from a collection

 

let getIdArray (ids : ObjectIdCollection) =

  [| for i in [0..ids.Count-1] -> ids.[i] |]

 

// Declare our command

 

[<CommandMethod("pix")>]

let pixelize() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // Prompt the user for the file and the width of the image

 

  let pofo =

    new PromptOpenFileOptions

      ("Select an image to import and pixelize")

  pofo.Filter <-

    "Jpeg Image (*.jpg)|*.jpg|All files (*.*)|*.*"

  let pfnr = ed.GetFileNameForOpen(pofo)

 

  let file =

    match pfnr.Status with

    | PromptStatus.OK ->

        pfnr.StringResult

    | _ ->

        ""

 

  if System.IO.File.Exists(file) then

 

    let img = System.Drawing.Image.FromFile(file)

 

    let pio =

      new PromptIntegerOptions

        ("\nEnter number of horizontal pixels: ")

    pio.AllowNone <- true

    pio.UseDefaultValue <- true

    pio.LowerLimit <- 1

    pio.UpperLimit <- img.Width

    pio.DefaultValue <- 100

 

    let pir = ed.GetInteger(pio)

    let xsize =

      match pir.Status with

        | PromptStatus.None ->

            img.Width

        | PromptStatus.OK ->

            pir.Value

        | _ -> -1

 

    if xsize > 0 then

 

      // Calculate the vertical size from the horizontal

 

      let ysize = img.Height * xsize / img.Width

 

      if ysize > 0 then

 

        // We'll time the command, so we can check the

        // sync vs. async efficiency

 

        let starttime = System.DateTime.Now

 

        // "use" has the same effect as "using" in C#

 

        use tr =

          db.TransactionManager.StartTransaction()

 

        // Get appropriately-typed BlockTable and BTRs

 

        let bt =

          tr.GetObject

            (db.BlockTableId,OpenMode.ForRead)

          :?> BlockTable

 

        let ms =

          tr.GetObject

            (bt.[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite)

          :?> BlockTableRecord

 

        // Function to create a filled circle (hatch) at a

        // specific location

 

        // Note the valid use of tr and ms, as they are in scope

 

        let createCircle pt rad =

          let hat = new Hatch()

          hat.SetDatabaseDefaults()

          hat.SetHatchPattern

            (HatchPatternType.PreDefined,

            "SOLID")

 

          let id = ms.AppendEntity(hat)

          tr.AddNewlyCreatedDBObject(hat, true)

 

          // Now we create the loop, which we make db-resident

          // (appending a transient loop caused problems, so

          // we're going to use the circle and then erase it)

 

          let cir = new Circle()

          cir.Radius <- rad

          cir.Center <- pt

 

          let lid = ms.AppendEntity(cir)

          tr.AddNewlyCreatedDBObject(cir, true)

 

          // Have the hatch use the loop we created

 

          let loops = new ObjectIdCollection()

          loops.Add(lid) |> ignore

          hat.AppendLoop(HatchLoopTypes.Default, loops)

          hat.EvaluateHatch(true)

 

          // Now we erase the loop

 

          cir.Erase()

          id

 

        // Function to create our grid of circles

 

        let createGrid xsize ysize rad offset =

          let ids = new ObjectIdCollection()

          for i = 0 to xsize - 1 do

            for j = 0 to ysize - 1 do

              let pt =

                new Point3d

                  (offset * (Int32.to_float i),

                   offset * (Int32.to_float j),

                   0.0)

              let id = createCircle pt rad

              ids.Add(id) |> ignore

          ids

 

        // Function to change the colour of an entity

 

        let changeColour (id : ObjectId) (col : Color) =

          if id.IsValid then

            let ent =

              tr.GetObject(id, OpenMode.ForWrite) :?> Entity

            ent.Color <- col

 

        // Create our basic grid

 

        let ids = createGrid xsize ysize 0.5 1.2

 

        // Cast our image to a bitmap and then

        // get the chunked pixels

 

        let bmp = img :?> System.Drawing.Bitmap

        let arr = pixelizeBitmap bmp xsize ysize

 

        // Loop through the pixel list and average them out

        // (which could be parallelized), using the results

        // to change the colour of the circles in our grid

 

        Array.map getAverageColour arr |>

          Array.iter2 changeColour (getIdArray ids)

 

        // Commit the transaction

 

        tr.Commit()

 

        // Check how long it took

 

        let elapsed =

          System.DateTime.op_Subtraction

            (System.DateTime.Now, starttime)

 

        ed.WriteMessage

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

To change this to run the colour averaging asynchronously (in parallel, if you have the cores) is really simple. We replace one line of code "Array.map getAverageColour arr" with the following:

Async.Run

  (Async.Parallel

    [ for a in arr ->

        async { return getAverageColour a }])

This essentially performs a parallel array map (albeit a somewhat naive one), returning basically the same results as the previous line - just hopefully a little more quickly. In case you want to build the two files into one project to test them side-by-side, here they are, the synchronous and asynchronous versions, with the changes needed to allow them to live in and execute from the same assembly.

Here's one more image that's been processed by the PIX command:

In case you're interested, the original image can be found here.

Importing and pixelizing images inside AutoCAD using F#

A friend and esteemed colleague asked - very validly - why I decided to use circles on a grid to display the results of a mathematical function in this last post, rather than using a linear object of some kind. Well I did, in fact, have a plan in mind... :-)

This post extends the concept, introduced in that post, of displaying data in a grid of solid-hatched circles. This post focuses on importing a bitmap image from a file, pixelizing the contents and using the "averaged" pixel colours to modify our grid. The idea actually came to me during an R.E.M. concert I attended at Paléo, a Swiss music festival, last summer. The real-time manipulation performed on the live video feed of the band - and especially of Michael Stipe, the lead singer - which was then projected onto screens adjacent to the stage was really, really cool. They managed to pixelize and manipulate the colours in a way that I found incredible - it was like seeing real-time graphic design at work. I understand that much of the work is done in advance, but even so I found it very impressive. Some of you regular concert-goers may find what I've just described to be pretty run-of-the-mill, but I fully admit that these days - what with one thing and another - I don't get out much. :-)

The pixelization approach I decided to take was to read in square chunks of the bitmap image and then average out the RGB values for all the pixels in each square. These average values are then used to colour the circles representing the "pixels" for their respective squares. You'll notice some inadvertent cropping of the imported image, which happens because we ask for the width in terms of our circular pixels and then sample the bitmap in chunks that have a whole number of pixels on each side: if the picture's width is not exactly divisible by the width entered there will be a little cropping.

Why did I choose F# for this rather than C#? The image processing domain in general is a strong fit for functional programming techniques. And while I haven't yet taken the step in this post, certain parts of the below code are inherently parallelizable, especially the operations related to averaging of pixel colours. The reading of the bitmap itself might prove more difficult, as it uses "unsafe" direct memory access (via the NativePtr class), but it's by no means impossible to parallelize, at least in theory.

Anyway, here's the F# code I put together:

// Use lightweight F# syntax

#light

// Declare a specific namespace and module name

module Pixelizor.Commands

// Import managed assemblies

#nowarn "9" // ... because we're using NativePtr

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open Autodesk.AutoCAD.Colors

open System.Drawing.Imaging

open Microsoft.FSharp.NativeInterop

// Declare our command

[<CommandMethod("pix")>]

let pixelate() =

  // Let's get the usual helpful AutoCAD objects

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

  // "use" has the same effect as "using" in C#

  use tr =

    db.TransactionManager.StartTransaction()

  // Get appropriately-typed BlockTable and BTRs

  let bt =

    tr.GetObject

      (db.BlockTableId,OpenMode.ForRead)

    :?> BlockTable

  let ms =

    tr.GetObject

      (bt.[BlockTableRecord.ModelSpace],

      OpenMode.ForWrite)

    :?> BlockTableRecord

  // Function to create a filled circle (hatch) at a

  // specific location

  // Note the valid use of tr and ms, as they are in scope

  let createCircle pt rad =

    let hat = new Hatch()

    hat.SetDatabaseDefaults()

    hat.SetHatchPattern

      (HatchPatternType.PreDefined,

      "SOLID")

    let id = ms.AppendEntity(hat)

    tr.AddNewlyCreatedDBObject(hat, true)

    // Now we create the loop, which we make db-resident

    // (appending a transient loop caused problems, so

    // we're going to use the circle and then erase it)

    let cir = new Circle()

    cir.Radius <- rad

    cir.Center <- pt

    let lid = ms.AppendEntity(cir)

    tr.AddNewlyCreatedDBObject(cir, true)

    // Have the hatch use the loop we created

    let loops = new ObjectIdCollection()

    loops.Add(lid) |> ignore

    hat.AppendLoop(HatchLoopTypes.Default, loops)

    hat.EvaluateHatch(true)

    // Now we erase the loop

    cir.Erase()

    id

  // Function to create our grid of circles

  let createGrid xsize ysize rad offset =

    let ids = new ObjectIdCollection()

    for i = 0 to xsize - 1 do

      for j = 0 to ysize - 1 do

        let pt =

          new Point3d

            (offset * (Int32.to_float i),

            offset * (Int32.to_float j),

            0.0)

        let id = createCircle pt rad

        ids.Add(id) |> ignore

    ids

  // Function to change the colour of an entity

  let changeColour (col : Color) (id : ObjectId) =

    if id.IsValid then

      let ent =

        tr.GetObject(id, OpenMode.ForWrite) :?> Entity

      ent.Color <- col

  // Add up the RGB values of a list of pixels

  // We use a recursive function with an accumulator argument,

  // (rt, gt, bt), to allow tail call optimization

  let rec sumColors (pix : List<(byte*byte*byte)>) (rt,gt,bt) =

    match pix with

      | [] -> (rt, gt, bt)

      | (r, g, b) :: tl ->

          sumColors tl

            (rt + Byte.to_int r,

            gt + Byte.to_int g,

            bt + Byte.to_int b)

  // Average out the RGB values of a list of pixels

  let getAverageColour (pixels : List<(byte*byte*byte)>) =

    let (rsum, gsum, bsum) =

      sumColors pixels (0, 0, 0)

    let count = pixels.Length

    let ravg = Byte.of_int (rsum / count)

    let gavg = Byte.of_int (gsum / count)

    let bavg = Byte.of_int (bsum / count)

    // For some reason the pixel needs ro be reversed - probably

    // because of the bitmap format (needs investigation)

    Color.FromRgb(bavg, gavg, ravg)

  //  Get a chunk of pixels to average from one row

  // We use a recursive function with an accumulator argument

  // to allow tail call optimization

  let rec getChunkRowPixels p xsamp acc =

    if xsamp = 0 then

      acc

    else

      let pix =

        [(NativePtr.get p 0,

          NativePtr.get p 1,

          NativePtr.get p 2)]

      let p = NativePtr.add p 3

      getChunkRowPixels p (xsamp-1) (pix @ acc)

  // Get a chunk of pixels to average from multiple rows

  // We use a recursive function with an accumulator argument

  // to allow tail call optimization

  let rec getChunkPixels p stride xsamp ysamp acc =

    if ysamp = 0 then

      acc

    else

      let pix = getChunkRowPixels p xsamp []

      let p = NativePtr.add p stride

      getChunkPixels p stride xsamp (ysamp-1) (pix @ acc)

  // Get the various chunks of pixels to average across

  // a complete bitmap image

  let pixelateBitmap (image:System.Drawing.Bitmap) xsize ysize =

    // Create a 2-dimensional array of pixel lists (one list,

    // which then needs averaging, per final pixel)

    let (arr2 : List<(byte*byte*byte)>[,]) =

      Array2.create xsize ysize []

    // Lock the entire memory block related to our image

    let bd =

      image.LockBits

        (System.Drawing.Rectangle

          (0, 0, image.Width ,image.Height),

        ImageLockMode.ReadOnly, image.PixelFormat)

    // Establish the number of pixels to sample per chunk

    // in each of the x and y directions

    let xsamp = image.Width / xsize

    let ysamp = image.Height / ysize

    // We have a mutable pointer to step through the image

    let mutable (p:nativeptr<byte>) =

      NativePtr.of_nativeint (bd.Scan0)

    // Loop through the various chunks

    for i = 0 to ysize - 1 do

      // We take a copy of the current value of p, as we

      // don't want to mutate p while extracting the pixels

      // within a row

      let mutable xp = p

      for j = 0 to xsize - 1 do

        // Get the square chunk of pixels starting at

        // this x,y position

        let chk =

          getChunkPixels xp bd.Stride xsamp ysamp []

        // Add it into our array

        arr2.[j,ysize-1-i] <- chk

        // Mutate the pointer to move along to the right

        // by a value of 3 (our RGB value) times the

        // number of pixels we're sampling in x

        xp <- NativePtr.add xp (xsamp * 3)

      done

      // Mutate the original p pointer to move on one row

      p <- NativePtr.add p (bd.Stride * ysamp)

    done

    // Finally unlock the bitmap data and return the array

    image.UnlockBits(bd)

    arr2

  // Prompt the user for the file and the width of the image

  let pofo =

    new PromptOpenFileOptions

      ("Select an image to import and pixelate")

  pofo.Filter <-

    "Jpeg Image (*.jpg)|*.jpg|All files (*.*)|*.*"

  let pfnr = ed.GetFileNameForOpen(pofo)

  let file =

    match pfnr.Status with

    | PromptStatus.OK ->

        pfnr.StringResult

    | _ ->

        ""

  if System.IO.File.Exists(file) then

    let img = System.Drawing.Image.FromFile(file)

    let pio =

      new PromptIntegerOptions

        ("\nEnter number of horizontal pixels: " )

    pio.AllowNone <- true

    pio.UseDefaultValue <- true

    pio.LowerLimit <- 1

    pio.UpperLimit <- img.Width

    pio.DefaultValue <- 100

    let pir = ed.GetInteger(pio)

    let xsize =

      match pir.Status with

        | PromptStatus.None ->

            img.Width

        | PromptStatus.OK ->

            pir.Value

        | _ -> -1

    if xsize > 0 then

      // Calculate the vertical size from the horizontal

      let ysize = img.Height * xsize / img.Width

      if ysize > 0 then

        // Create our basic grid

        let ids = createGrid xsize ysize 0.5 1.2

        // Some helper functions using values we've just set...

        // From a certain index in the list, get an object ID

        let getId i =

          if i >= 0 then

            ids.[i]

          else

            ObjectId.Null

        // From a certain x and y in the grid, get an object ID

        let getId x y =

          getId ((x * ysize) + y)

        // Cast our image to a bitmap and then

        // get the chunked pixels

        let bmp = img :?> System.Drawing.Bitmap

        let arr = pixelateBitmap bmp xsize ysize

        // Loop through the pixel list and average them out

        // (which could be parallelized), using the results

        // to change the colour of the circles in our grid

        for x = 0 to xsize - 1 do

          for y = 0 to ysize - 1 do

            let lst = arr.[x,y]

            let col = getAverageColour lst

            let id = getId x y

            changeColour col id

          done

        done

  // Commit the transaction

  tr.Commit()

Here are the results of running it and choosing a photo I took yesterday during my visit to Kodaikanal in Tamil Nadu (India's most southern state).

First the original image:

Here's what happens when we run the PIX command, selecting the above image and choosing 20 pixels in width:

 

Now with a width of 50...

And finally with a width of 100...

 

Give it a try yourself, pixelizing different images at different resolutions - you can get some very cool results.

This one is too fun to just let rest... I'm going to see if I get some time this week to work on the parallelization of the colour averaging operation, to see if that improves performance (even if it doesn't today, it will do eventually when I either get a 64-core machine or move some of the code to be hosted in the cloud... :-)

Robotic hatching inside AutoCAD using F# and .NET

I had too much fun with the last post just to let it drop: I decided to port the main command to F#, to show how it's possible to combine C# and F# inside a single project.

The premise I started with was that the point-in-curve.cs library is something that we know works - and don't want to re-write - but would like to use from a new application we're developing in F#. This also gives us the chance to compare the performance between C# and F# when solving the same problem (although as we'll be calling through to some C# code from F# this isn't a pure comparison, in truth).

Anyway, on the train heading for Zurich, before flying back out to San Francisco again (yes, I'm back in San Rafael for another couple of days), I finished up the F# equivalent code for the last post's bounce-hatch.cs file.

Here's the F# code:

// 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.")

I should make a few points about this

• The code is pretty rough - while I tried to solve the problem in a "functional" style, I was re-writing an "imperative" application, so my thinking was a little entrenched. That said, I was able to use some functional techniques to solve certain bits of the problem more elegantly, I believe.
• The performance is on a par (and at times slightly quicker) than the equivalent C# code
• That said, when trying to bounce 400 or more times (on my system, at least) I get a fatal error. I suspect some stack limit is being reached: when running from the debugger this is not hit, although the performance is much slower.

I need to do some more work on this at some point, but I though I'd post it now along with the complete project. I'm going to have a fairly hectic few days here, but will try to post something more at the end of the week.

Robotic hatching inside AutoCAD using .NET

This may strike you as a fairly bizarre title for a post, but I was inspired to develop the below code by a robotic lawnmower we bought about a year ago. This fantastic tool bounces around our garden, changing direction randomly when it hits the lawn's boundary. I got to thinking how to implement a similar technique to hatch a boundary with a polyline. While this is mostly for fun, I can see a few interesting potential uses: you might use the technique to test randomly generated paths of, for example, a robot or you might simply want to supplement traditional hatching with something more random in nature.

The principle is actually very simple: we're going to take a point on the edge of the boundary, and fire a ray (an infinite line) in a random direction - but planar to the boundary - and find out where it intersects the boundary. The tricky piece is that - depending on how "jagged" your boundary is - the ray may actually intersect multiple (i.e. > 2) times. If we want to stay inside the boundary - a requirement for my little robotic hatcher - we need to exclude the segments that would lead us to exiting the boundary to reach the other end.

Excluding the "bad" segments actually proved to be the tricky part. I ended up taking a DevNote from the ADN site (Testing Whether A Point Lies Inside A Curve, for those of you who are ADN members), and converting the C++ code to C#. I won't comment much on the implementation - it's using a similar technique to the one I have in my own code, firing rays to determine intersections - but to be frank I'm only vaguely aware of how it works (ah, the joys of copy & paste development :-).

Here's the converted code. I have it saved in a file called point-in-curve.cs, but clearly the specific name doesn't matter, as long as it is included in your project.

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Geometry;

namespace PointInCurve

{

  public class Fns

  {

    enum IncidenceType

    {

      ToLeft = 0,

      ToRight = 1,

      ToFront = 2,

      Unknown

    };

    static IncidenceType CurveIncidence(

      Curve cur,

      double param,

      Vector3d dir,

      Vector3d normal

    )

    {

      Vector3d deriv1 =

        cur.GetFirstDerivative(param);

      if (deriv1.IsParallelTo(dir))

      {

        // Need second degree analysis

        Vector3d deriv2 =

          cur.GetSecondDerivative(param);

        if (deriv2.IsZeroLength() ||

            deriv2.IsParallelTo(dir))

          return IncidenceType.ToFront;

        else

          if (deriv2.CrossProduct(dir).

              DotProduct(normal) < 0)

            return IncidenceType.ToRight;

          else

            return IncidenceType.ToLeft;

      }

      if (deriv1.CrossProduct(dir).

          DotProduct(normal) < 0)

        return IncidenceType.ToLeft;

      else

        return IncidenceType.ToRight;

    }

    static public bool IsInsideCurve(

      Curve cur,

      Point3d testPt

    )

    {

      if (!cur.Closed)

        // Cannot be inside

        return false;

      Polyline2d poly2d = cur as Polyline2d;

      if (poly2d != null &&

          poly2d.PolyType != Poly2dType.SimplePoly)

        // Not supported

        return false;

      Point3d ptOnCurve =

        cur.GetClosestPointTo(testPt, false);

      if (Tolerance.Equals(testPt, ptOnCurve))

        return true;

      // Check it's planar

      Plane plane = cur.GetPlane();

      if (!cur.IsPlanar)

        return false;

      // Make the test ray from the plane

      Vector3d normal = plane.Normal;

      Vector3d testVector =

        normal.GetPerpendicularVector();

      Ray ray = new Ray();

      ray.BasePoint = testPt;

      ray.UnitDir = testVector;

      Point3dCollection intersectionPoints =

        new Point3dCollection();

      // Fire the ray at the curve

      cur.IntersectWith(

        ray,

        Intersect.OnBothOperands,

        intersectionPoints,

        0, 0

      );

      ray.Dispose();

      int numberOfInters =

        intersectionPoints.Count;

      if (numberOfInters == 0)

        // Must be outside

        return false;

      int nGlancingHits = 0;

      double epsilon = 2e-6; // (trust me on this)

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

      {

        // Get the first point, and get its parameter

        Point3d hitPt = intersectionPoints[i];

        double hitParam =

          cur.GetParameterAtPoint(hitPt);

        double inParam = hitParam - epsilon;

        double outParam = hitParam + epsilon;

        IncidenceType inIncidence =

          CurveIncidence(cur, inParam, testVector, normal);

        IncidenceType outIncidence =

          CurveIncidence(cur, outParam, testVector, normal);

        if ((inIncidence == IncidenceType.ToRight &&

            outIncidence == IncidenceType.ToLeft) ||

            (inIncidence == IncidenceType.ToLeft &&

            outIncidence == IncidenceType.ToRight))

          nGlancingHits++;

      }

      return ((numberOfInters + nGlancingHits) % 2 == 1);

    }

  }

}

I then implemented my own code to make use of this library (in this case saved in bounce-hatch.cs):

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.EditorInput;

using PointInCurve;

namespace BounceHatch

{

  public class Commands

  {

    // Get a vector in a random direction

    public Vector3d randomUnitVector(

      PlanarEntity pl

    )

    {

      // Create our random number generator

      System.Random ran =

        new System.Random();

      // First we get the absolute value

      // of our x and y coordinates

      double x = ran.NextDouble();

      double y = ran.NextDouble();

      // Then we negate them, half of the time

      if (ran.NextDouble() < 0.5)

        x = -x;

      if (ran.NextDouble() < 0.5)

        y = -y;

      // Create a 2D vector and return it as

      //  3D on our plane

      Vector2d v2 = new Vector2d(x, y);

      return new Vector3d(pl, v2);

    }

    // Allow tracing in 3 colours, depending on

    // whether the vector was accepted, rejected,

    // or superseded by a better one

    enum TraceType

    {

      Accepted = 0,

      Rejected = 1,

      Superseded = 2

    };

    void TraceSegment(

      Point3d start,

      Point3d end,

      TraceType type

    )

    {

      Editor ed =

        Application.DocumentManager.MdiActiveDocument.Editor;

      int vecCol = 0;

      switch (type)

      {

        case TraceType.Accepted:

          vecCol = 3;

          break;

        case TraceType.Rejected:

          vecCol = 1;

          break;

        case TraceType.Superseded:

          vecCol = 2;

          break;

      }

      Matrix3d trans =

        ed.CurrentUserCoordinateSystem.Inverse();

      ed.DrawVector(

        start.TransformBy(trans),

        end.TransformBy(trans),

        vecCol,

        false

      );

    }

    // Test whether a segment goes outside our boundary

    bool TestSegment(

      Curve cur,

      Point3d start,

      Vector3d vec

    )

    {

      // Test 10 points along the segment...

      // (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.)

      bool result = true;

      for (int i = 1; i < 10; i++)

      {

        Point3d test = start + (vec * 0.1 * i);

        // Call into our IsInsideCurve library function,

        // "and"-ing the results

        result &=

          PointInCurve.Fns.IsInsideCurve(cur, test);

        if (!result)

          break;

      }

      return result;

    }

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

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

    Point3d nextBoundaryPoint(

      Curve cur,

      Point3d start,

      bool trace

    )

    {

      // Create and define our ray

      Ray ray = new Ray();

      ray.BasePoint = start;

      ray.UnitDir =

        randomUnitVector(cur.GetPlane());

      // Get the intersection points until we

      // have at least 2 returned

      // (will usually happen straightaway)

      Point3dCollection pts =

        new Point3dCollection();

      do

      {

        cur.IntersectWith(

          ray,

          Intersect.OnBothOperands,

          pts,

          0, 0

        );

        if (pts.Count < 2)

        {

          ray.UnitDir =

            randomUnitVector(cur.GetPlane());

        }

      }

      while (pts.Count < 2);

      ray.Dispose();

      // 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

      bool first = true;

      double nextLen = 0.0;

      Point3d nextPt = start;

      foreach (Point3d pt in pts)

      {

        // Get the distance between this intersection

        // and the last accepted point - both points

        // are on our ray

        Vector3d vec = pt - start;

        double len = vec.Length;

        // If the vector length is positive and either

        // the first to be a candidate or closer than

        // the previous one (we generally select the

        // closest non-zero option) then check it out

        // further

        if (len > Tolerance.Global.EqualVector &&

            (first || len < nextLen))

        {

          // Run our tests to make sure the segment is

          // inside our boundary

          if (TestSegment(cur, start, vec))

          {

            // Draw the previous segment before overwriting

            if (trace)

              TraceSegment(

                start,

                nextPt,

                TraceType.Superseded

              );

            nextLen = len;

            nextPt = pt;

            first = false;

          }

          else

            // This segment has been rejected,

            // as it goes outside

            if (trace)

              TraceSegment(

                start,

                pt,

                TraceType.Rejected

              );

        }

      }

      // Draw our accepted segment and return it

      if (nextLen > Tolerance.Global.EqualVector)

      {

        if (trace)

          TraceSegment(

            start,

            nextPt,

            TraceType.Accepted

          );

        return nextPt;

      }

      else

        // If we didn't find a good segment, throw an

        // exception to be handled by the calling function

        throw new Exception(

          ErrorStatus.PointNotOnEntity,

          "Could not find another intersection point."

        );

    }

    [CommandMethod("BOUNCE")]

    public void BounceHatch()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      bool doTrace = false;

      // Get various bits of user input

      PromptEntityOptions peo =

        new PromptEntityOptions(

          "\nSelect point on closed loop: "

        );

      PromptEntityResult per =

        ed.GetEntity(peo);

      if (per.Status != PromptStatus.OK)

        return;

      PromptIntegerOptions pio =

        new PromptIntegerOptions(

          "\nEnter number of segments: "

          );

      pio.DefaultValue = 500;

      PromptIntegerResult pir =

        ed.GetInteger(pio);

      if (pir.Status != PromptStatus.OK)

        return;

      PromptKeywordOptions pko =

        new PromptKeywordOptions(

          "\nDisplay segment trace: "

        );

      pko.Keywords.Add("Yes");

      pko.Keywords.Add("No");

      pko.Keywords.Default = "Yes";

      PromptResult pkr =

        ed.GetKeywords(pko);

      if (pkr.Status != PromptStatus.OK)

        return;

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

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

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

        DBObject obj =

          tr.GetObject(per.ObjectId, OpenMode.ForRead);

        Curve cur = obj as Curve;

        if (cur == null)

          ed.WriteMessage("\nThis is not a curve.");

        else

        {

          if (!cur.Closed)

            ed.WriteMessage("\nLoop is not closed.");

          else

          {

            // Extract parameters from our user-input...

            // A flag for our vector tracing

            doTrace = (pkr.StringResult == "Yes");

            // The number of segments

            int numBounces = pir.Value;

            // The first vertex of our path

            Point3d latest =

              per.PickedPoint.

                TransformBy(ed.CurrentUserCoordinateSystem).

                  OrthoProject(cur.GetPlane());

            // Create our polyline path, adding the

            // initial vertex

            Polyline path = new Polyline();

            path.Normal = cur.GetPlane().Normal;

            path.AddVertexAt(

              0,

              latest.Convert2d(cur.GetPlane()),

              0.0, 0.0, 0.0

            );

            // For each segment, get the next vertex

            // and add it to the path

            int i = 1;

            while (i <= numBounces)

            {

              try

              {

                Point3d next =

                  nextBoundaryPoint(cur, latest, doTrace);

                path.AddVertexAt(

                  i++,

                  next.Convert2d(cur.GetPlane()),

                  0.0, 0.0, 0.0

                );

                latest = next;

              }

              catch (Exception ex)

              {

                // If there's an exception we know about

                // then ignore it and allow the loop to

                // continue (we probably did not increment

                // i in this case, as it will fail on

                // nextBoundaryPoint)

                if (ex.ErrorStatus !=

                    ErrorStatus.PointNotOnEntity)

                  throw ex;

              }

            }

            // Open the modelspace

            BlockTable bt =

              (BlockTable)

                tr.GetObject(

                  db.BlockTableId,

                  OpenMode.ForRead

                );

            BlockTableRecord btr =

              (BlockTableRecord)

                tr.GetObject(

                  bt[BlockTableRecord.ModelSpace],

                  OpenMode.ForWrite

                );

            // 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);

            tr.AddNewlyCreatedDBObject(path, true);

          }

        }

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

        tr.Commit();

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

        // before regenerating the graphics

        if (doTrace)

        {

          pko =

            new PromptKeywordOptions(

              "\nPress return to clear trace vectors: "

            );

          pko.AllowNone = true;

          pko.AllowArbitraryInput = true;

          pkr = ed.GetKeywords(pko);

          ed.Regen();

        }

      }

    }

  }

}

As I've mentioned in the above code, this is not the most efficient possible implementation: we do several (currently 10) checks per potential vertex, to see whether it needs to be excluded. This number might well be reduced, or the library could be updated to provide a more efficient implementation. But for our purposes it works fine, so I'm not going to worry too much. Optimization is left as an exercise for the reader. :-)

Here's what happens when we run the BOUNCE command on a couple of boundaries. The first one I just created for testing - it's a lightweight polyline with three downward prongs that makes it likely that rays fired from the boundary will intersect it multiple (>2) times. For each of these examples I've composed three views: the boundary (pre-hatching), the trace vectors displayed to show the successful vectors (in green) and the excluded vectors (in red), and then the final hatch.

This first loop has been hatched with 100 segments, to clearly show the way the pattern works (or can work, as it's randomly generated).

The second loop I started drawing with straight segments and then switched to arcs. Somehow I ended up creating something that looks like it's out of Alien, although I wasn't (consciously, at least) in any way inspired by Giger (even though he's Swiss and has a museum in nearby Gruyères). Anyway, this one I hatched with 1000 segments, selecting the initial point on the boundary of the left-most leg: you can see that even with that many segments, not every piece of the boundary was reached using a random algorithm.

Update:

While working with this a little more, I realised I was not disposing the ray objects we were using for intersection calculations. I've now fixed the above code by inserting calls to ray.Dispose() in the appropriate places.

Applying a gradient fill to an AutoCAD hatch using .NET

So, back in the saddle after an eventful week off, back in the UK. Aside from the extremely changeable weather (even by British standards) and the heightened security at UK airports, the week went swimmingly... :-)

It's now Friday night, and disappointingly I've spent nearly two days regaining control of my inbox. I really wanted to make a quick post before the weekend, so rather than diving into the issue I'd planned on tackling (Palettes), I decided to take a shot at a request I'd received by email a few weeks ago: to show how to create a gradient fill using .NET.

I started by reusing the code from this previous post: so much of the code I needed was there already, it had to be easy to adjust the hatch to use a gradient fill, right? Well, no - it took me much longer than I'd expected to work this one out. Maybe I should have stuck with Palettes, after all...

I decided to use a spherical gradient fill of two colours (the default colours used when you create a two-tone gradient fill using the UI), as this shows one of the trickier parts of the API, that of specifying the colours themselves. One other call it took me a while to work out was to set the HatchObjectType property - if you don't do that then you'll get an eAmbiguousOutput exception.

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Colors;

namespace HatchGradient

{

  public class Commands

  {

    [CommandMethod("GFH")]

    static public void GradientFillHatch()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      // Ask the user to select a hatch boundary

      PromptEntityOptions opt =

        new PromptEntityOptions(

          "\nSelect boundary: "

        );

      opt.SetRejectMessage("\nObject must be a curve.");

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

      PromptEntityResult res =

        ed.GetEntity(opt);

      if (res.Status == PromptStatus.OK)

      {

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          // Check the entity is a closed curve

          DBObject obj =

            tr.GetObject(

              res.ObjectId,

              OpenMode.ForRead

            );

          Curve cur = obj as Curve;

          if (cur != null && cur.Closed == false)

          {

            ed.WriteMessage("\nLoop must be a closed curve.");

          }

          else

          {

            // We'll add the hatch to the model space

            BlockTable bt =

              (BlockTable)tr.GetObject(

                doc.Database.BlockTableId,

                OpenMode.ForRead

              );

            BlockTableRecord btr =

              (BlockTableRecord)tr.GetObject(

                bt[BlockTableRecord.ModelSpace],

                OpenMode.ForWrite

              );

            Hatch hat = new Hatch();

            hat.SetDatabaseDefaults();

            // Firstly make it clear we want a gradient fill

            hat.HatchObjectType =

              HatchObjectType.GradientObject;

            // Let's use the pre-defined spherical gradient

            hat.SetGradient(

              GradientPatternType.PreDefinedGradient,

              "SPHERICAL");

            // We're defining two colours

            hat.GradientOneColorMode = false;

            GradientColor[] gcs = new GradientColor[2];

            gcs[0] =

              new GradientColor(

                Color.FromRgb(0, 0, 255),

                0 // First colour must have value of 0

              );

            gcs[1] =

              new GradientColor(

                Color.FromRgb(255, 255, 153),

                1 // Second colour must have value of 1

              );

            hat.SetGradientColors(gcs);

            // Add the hatch to the model space

            // and the transaction

            ObjectId hatId = btr.AppendEntity(hat);

            tr.AddNewlyCreatedDBObject(hat, true);

            // Add the hatch loop and complete the hatch

            ObjectIdCollection ids =

              new ObjectIdCollection();

            ids.Add(res.ObjectId);

            hat.Associative = true;

            hat.AppendLoop(

              HatchLoopTypes.Default,

              ids

            );

            hat.EvaluateHatch(true);

            tr.Commit();

          }

        }

      }

    }

  }

}

Here's what you get when you run the GFH command and select a polyline boundary you've created previously:

That's it for this week - have a great weekend, all of you.

Manipulating the draw order of a newly created AutoCAD hatch using .NET

This question came in from Limin as a comment in this previous post:

Is there .Net interface for autocad command "DrawOrder"? For example: after solid-hatch a polyline, need to reorder polyline and hatch, how to make it happen using .NET?

I've put together some C# code to demonstrate how to do this:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

namespace HatchDrawOrder

{

  public class Commands

  {

    [CommandMethod("HDO")]

    static public void HatchDrawOrder()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

      // Ask the user to select a hatch boundary

      PromptEntityOptions opt =

        new PromptEntityOptions(

          "\nSelect boundary: "

        );

      opt.SetRejectMessage("\nObject must be a curve.");

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

      PromptEntityResult res =

        ed.GetEntity(opt);

      if (res.Status == PromptStatus.OK)

      {

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          // Check the entity is a closed curve

          DBObject obj =

            tr.GetObject(

              res.ObjectId,

              OpenMode.ForRead

            );

          Curve cur = obj as Curve;

          if (cur != null && cur.Closed == false)

          {

            ed.WriteMessage("\nLoop must be a closed curve.");

          }

          else

          {

            // Add the hatch to the model space

            BlockTable bt =

              (BlockTable)tr.GetObject(

                doc.Database.BlockTableId,

                OpenMode.ForRead

              );

            BlockTableRecord btr =

              (BlockTableRecord)tr.GetObject(

                bt[BlockTableRecord.ModelSpace],

                OpenMode.ForWrite

              );

            Hatch hat = new Hatch();

            hat.SetDatabaseDefaults();

            hat.SetHatchPattern(

              HatchPatternType.PreDefined,

              "SOLID"

            );

            ObjectId hatId = btr.AppendEntity(hat);

            tr.AddNewlyCreatedDBObject(hat, true);

            // Add the hatch loop and complete the hatch

            ObjectIdCollection ids =

              new ObjectIdCollection();

            ids.Add(res.ObjectId);

            hat.Associative = true;

            hat.AppendLoop(

              HatchLoopTypes.Default,

              ids

            );

            hat.EvaluateHatch(true);

            // Change the draworder of both hatch and loop

            btr.DowngradeOpen();

            ids.Add(hatId);

            DrawOrderTable dot =

              (DrawOrderTable)tr.GetObject(

                btr.DrawOrderTableId,

                OpenMode.ForWrite

              );

            dot.MoveToBottom(ids);

            tr.Commit();

          }

        }

      }

    }

  }

}

The code to manipulate the draw order of these two entities is very simple - we have to open the DrawOrderTable for the space containing the entities we care about, and use it to change the order in which the entities are drawn. In this case I chose to send them both to the back of the draw order stack, but you might also manipulate their draw order relative to other entities in the drawing.

On a personal note, my family and I have arrived safely in Beijing - we're all a bit jet-lagged, but very happy to be here. The journey was thankfully uneventful, and with two young children that's really as much as you can hope for. :-)

Showing AutoCAD's hatch dialog from a .NET application

This question was posted by csharpbird:

How to get the Hatch dialog using .NET? It seems that there is no such class in the .NET API?

It's true there is no public class - or even a published function - to show the hatch dialog inside AutoCAD. It is, however, possible to P/Invoke an unpublished (and therefore unsupported and liable to change without warning) function exported from acad.exe.

Here's some C# code that shows how. The code works for AutoCAD 2007, but will be different for AutoCAD 2006: the function takes and outputs strings, so the change to Unicode in 2007 will have modified the function signature.

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.ApplicationServices;

using System.Reflection;

using System.Runtime.InteropServices;

namespace HatchDialogTest

{

  public class Commands

  {

    [DllImport(

        "acad.exe",

        EntryPoint =

          "?acedHatchPalletteDialog@@YA_NPB_W_NAAPA_W@Z",

        CharSet = CharSet.Auto

      )

    ]

    static extern bool acedHatchPalletteDialog(

      string currentPattern,

      bool showcustom,

      out string newpattern

    );

    [CommandMethod("SHD")]

    static public void ShowHatchDialog()

    {

      string sHatchType;

      string sNewHatchType;

      bool bRet;

      sHatchType = "ANGLE";

      bRet =

        acedHatchPalletteDialog(

          sHatchType,

          true,

          out sNewHatchType

        );

      if (bRet)

      {

        Editor ed =

          Application.DocumentManager.MdiActiveDocument.Editor;

        ed.WriteMessage(

          "\nHatch type selected: " + sNewHatchType

        );

      }

    }

  }

}

Here's what happens when you run the code:

Command: SHD

Hatch type selected: SWAMP

Update

Someone asked me for the VB.NET code for this one (it was quite tricky to marshall the new string being returned). As I'd put it together, I thought I'd post it here:

Imports Autodesk.AutoCAD.ApplicationServices

Imports Autodesk.AutoCAD.Runtime

Imports Autodesk.AutoCAD.EditorInput

Imports System.Text

Namespace HatchDialogTest

  Public Class Commands

    Private Declare Auto Function acedHatchPalletteDialog _

    Lib "acad.exe" _

    Alias "?acedHatchPalletteDialog@@YA_NPB_W_NAAPA_W@Z" _

    (ByVal currentPattern As String, _

    ByVal showcustom As Boolean, _

    ByRef newpattern As StringBuilder) As Boolean

    <CommandMethod("SHD")> _

    Public Sub ShowHatchDialog()

      Dim sHatchType As String = "ANGLE"

      Dim sNewHatchType As New StringBuilder

      Dim bRet As Boolean = _

        acedHatchPalletteDialog(sHatchType, _

          True, sNewHatchType)

      If bRet And sNewHatchType.ToString.Length > 0 Then

        Dim ed As Editor

        ed = _

          Application.DocumentManager.MdiActiveDocument.Editor

        ed.WriteMessage( _

          vbLf + "Hatch type selected: " + _

          sNewHatchType.ToString)

      End If

    End Sub

  End Class

End Namespace

Update 2

I've recently come back to this post at the prompting of a colleague who was struggling to get it working with AutoCAD 2010. Sure enough, the dialog would appear but the marshalling back of the return string to AutoCAD is now causing a problem, for some unknown reason (at least it's unknown to me :-).

Anyway - to address the issue I've updated the code to perform the string marshalling a little more explicitly, and it now works. This may also address the issue one of the people commenting on this post experienced trying to get the code to work with AutoCAD 2009 (although I do remember testing it there and having no issues, which has me scratching my head somewhat).

Here's the updated C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.EditorInput;

using System.Runtime.InteropServices;

using System;

 

namespace HatchDialogTest

{

  public class Commands

  {

    [DllImport(

        "acad.exe",

        EntryPoint =

          "?acedHatchPalletteDialog@@YA_NPB_W_NAAPA_W@Z",

        CharSet = CharSet.Auto

      )

    ]

    static extern bool acedHatchPalletteDialog(

      string currentPattern,

      bool showcustom,

      out IntPtr newpattern

    );

 

    [CommandMethod("SHD")]

    static public void ShowHatchDialog()

    {

      string sHatchType = "ANGLE";

      IntPtr ptr;

      bool bRet =

        acedHatchPalletteDialog(

          sHatchType,

          true,

          out ptr

        );

      if (bRet)

      {

        string sNewHatchType = Marshal.PtrToStringAuto(ptr);

        if (sNewHatchType.Length > 0)

        {

          Editor ed =

            Application.DocumentManager.MdiActiveDocument.Editor;

          ed.WriteMessage(

            "\nHatch type selected: " + sNewHatchType

          );

        }

      }

    }

  }

}

And here's the updated VB code:

Imports Autodesk.AutoCAD.ApplicationServices

Imports Autodesk.AutoCAD.Runtime

Imports Autodesk.AutoCAD.EditorInput

Imports System.Runtime.InteropServices

Imports System

 

Namespace HatchDialogTest

 

  Public Class Commands

 

    Private Declare Auto Function acedHatchPalletteDialog _

    Lib "acad.exe" _

    Alias "?acedHatchPalletteDialog@@YA_NPB_W_NAAPA_W@Z" _

    (ByVal currentPattern As String, _

    ByVal showcustom As Boolean, _

    ByRef newpattern As IntPtr) As Boolean

 

    <CommandMethod("SHD")> _

    Public Sub ShowHatchDialog()

 

      Dim sHatchType As String = "ANGLE"

      Dim ptr As IntPtr

      Dim bRet As Boolean = _

        acedHatchPalletteDialog(sHatchType, _

          True, ptr)

      If bRet Then

        Dim sNewHatchType As String = _

          Marshal.PtrToStringAuto(ptr)

        If sNewHatchType.ToString.Length > 0 Then

          Dim ed As Editor

          ed = _

            Application.DocumentManager.MdiActiveDocument.Editor

          ed.WriteMessage( _

            vbLf + "Hatch type selected: " + sNewHatchType)

        End If

      End If

 

    End Sub

 

  End Class

 

End Namespace