Through the Interface

Merry Christmas and a Happy New Year!

Thank you all for reading and participating in this blog during 2010. It’s your comments and feedback that make it all worthwhile, at least from my perspective. (“If a blog post gets written and no-one’s around to read it, why bother spell-checking?” ;-)

I’m heading off to the Alps this afternoon with my family: we’ve rented a chalet in Haute-Nendaz for the week between Christmas and New Year and so I’ll be fully offline until the first week of January.

I hope you all get to enjoy a break – as Autodesk employees do during our “week of rest” – and come back refreshed and ready for some more AutoCAD .NET coding in 2011! :-)

A tool to help understand transformation matrices in AutoCAD

As promised, today’s post delivers a simple application that provides a user-interface for the command implemented in this previous post.

I chose to implement the UI as a WPF user control which is then hosted by a standard AutoCAD palette. Aside from its core function – to allow composition of transformation matrices to be applied on an AutoCAD object – it demonstrates a couple of handy tips for working with Palettes:

• Separate the core functionality from our UI, using SendStringToExecute() to call it
  • This will reduce the chance of issues related to Document vs. Session context, document-locking, etc.
• If you need to call a selection command in AutoCAD from your palette, use SetFocus() first
  • This will reduce a click to set focus on the main AutoCAD editing window
• Implement the SizeChanged() event to allow your hosted WPF user control to be resized
  • As mentioned in this previous post, WPF controls added to a PaletteSet via AddVisual() do not automatically resize with the palette
  • Rather than using an ElementHost() along with the standard WinForms Add() method, an event can be used
  • This makes for a slightly cleaner resize experience – from a graphics refresh perspective – as less thunking is needed

But you really needn’t worry about these details: the application is intended less for people interested in implementing a palette-hosted, WPF user control, rather than for people wanting to play around with and learn about transformation matrices. In fact, if you’re not at all interested in the coding specifics, feel free to skip down to the bottom of the post, where you’ll see the app in action.

To reflect the exploratory nature of the tool, I decided to implement a “playful” WPF theme for the palette found on this site. To make use of this theme, I also needed the WPF Toolkit, which I used from here (but probably could/should have picked up from here, as it seems more recent). The WPFToolkit.dll file needed by the application is included in the source project.

Here’s our updated C# code from the main plugin project:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

using System.Drawing;

using System.Reflection;

using System.Windows.Forms;

using System.Windows.Forms.Integration;

using System;

using MatrixEditor;

 

namespace Transformer

{

  public class App : IExtensionApplication

  {

    public void Initialize()

    {

      try

      {

        DemandLoading.RegistryUpdate.RegisterForDemandLoading();

      }

      catch

      { }

    }

 

    public void Terminate()

    {

    }

  }

 

  public class Commands

  {

    [CommandMethod("SELMATENT")]

    static public void SelectMatrixEntity()

    {

      Document doc =

        Autodesk.AutoCAD.ApplicationServices.

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      PromptEntityResult per = ed.GetEntity("\nSelect entity: ");

      if (per.Status != PromptStatus.OK)

        return;

 

      _mec.SetSelectedEntity(per.ObjectId);

    }

 

    [CommandMethod("TRANS", CommandFlags.UsePickSet)]

    static public void TransformEntity()

    {

      Document doc =

        Autodesk.AutoCAD.ApplicationServices.

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      // Our selected entity (only one supported, for now)

 

      ObjectId id;

 

      // First query the pickfirst selection set

 

      PromptSelectionResult psr = ed.SelectImplied();

      if (psr.Status != PromptStatus.OK || psr.Value == null)

      {

        // If nothing selected, ask the user

 

        PromptEntityOptions peo =

          new PromptEntityOptions(

            "\nSelect entity to transform: "

          );

        PromptEntityResult per = ed.GetEntity(peo);

        if (per.Status != PromptStatus.OK)

          return;

        id = per.ObjectId;

      }

      else

      {

        // If the pickfirst set has one entry, take it

 

        SelectionSet ss = psr.Value;

        if (ss.Count != 1)

        {

          ed.WriteMessage(

            "\nThis command works on a single entity."

          );

          return;

        }

        ObjectId[] ids = ss.GetObjectIds();

        id = ids[0];

      }

 

      PromptResult pr = ed.GetString("\nEnter property name: ");

      if (pr.Status != PromptStatus.OK)

        return;

 

      string prop = pr.StringResult;

 

      // Now let's ask for the matrix string

 

      pr = ed.GetString("\nEnter matrix values: ");

      if (pr.Status != PromptStatus.OK)

        return;

 

      // Split the string into its individual cells

 

      string[] cells = pr.StringResult.Split(new char[] { ',' });

      if (cells.Length != 16)

      {

        ed.WriteMessage("\nMust contain 16 entries.");

        return;

      }

 

      try

      {

        // Convert the array of strings into one of doubles

 

        double[] data = new double[cells.Length];

        for (int i = 0; i < cells.Length; i++)

        {

          data[i] = double.Parse(cells[i]);

        }

 

        // Create a 3D matrix from our cell data

 

        Matrix3d mat = new Matrix3d(data);

 

        // Now we can transform the selected entity

 

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          Entity ent =

            tr.GetObject(id, OpenMode.ForWrite)

            as Entity;

          if (ent != null)

          {

            bool transformed = false;

 

            // If the user specified a property to modify

 

            if (!string.IsNullOrEmpty(prop))

            {

              // Query the property's value

 

              object val =

                ent.GetType().InvokeMember(

                  prop, BindingFlags.GetProperty, null, ent, null

                );

 

              // We only know how to transform points and vectors

 

              if (val is Point3d)

              {

                // Cast and transform the point result

 

                Point3d pt = (Point3d)val,

                        res = pt.TransformBy(mat);

 

                // Set it back on the selected object

 

                ent.GetType().InvokeMember(

                  prop, BindingFlags.SetProperty, null,

                  ent, new object[] { res }

                );

                transformed = true;

              }

              else if (val is Vector3d)

              {

                // Cast and transform the vector result

 

                Vector3d vec = (Vector3d)val,

                        res = vec.TransformBy(mat);

 

                // Set it back on the selected object

 

                ent.GetType().InvokeMember(

                  prop, BindingFlags.SetProperty, null,

                  ent, new object[] { res }

                );

                transformed = true;

              }

            }

 

            // If we didn't transform a property,

            // do the whole object

 

            if (!transformed)

              ent.TransformBy(mat);

          }

          tr.Commit();

        }

      }

      catch (Autodesk.AutoCAD.Runtime.Exception ex)

      {

        ed.WriteMessage(

          "\nCould not transform entity: {0}", ex.Message

        );

      }

    }

 

    static PaletteSet _ps = null;

    static MatrixEditorControl _mec = null;

 

    [CommandMethod("MATRIX")]

    public void MatrixEditor()

    {

      if (_ps == null)

      {

        // Create the palette set

 

        _ps =

          new PaletteSet(

            "Matrix",

            new Guid("DB5A1D34-51E8-49c6-B607-FFFE21C48669")

          );

        _ps.Size = new Size(720, 630);

        _ps.DockEnabled =

          (DockSides)((int)DockSides.Left + (int)DockSides.Right);

 

        // Create our first user control instance and

        // host it on a palette using AddVisual()

 

        _mec = new MatrixEditorControl();

        _ps.AddVisual("MatrixEditor", _mec);

 

        // Resize the control when the palette resizes

 

        _ps.SizeChanged +=

          delegate(object sender, PaletteSetSizeEventArgs e)

          {

            _mec.Width = e.Width;

            _mec.Height = e.Height;

          };

      }

 

      // Display our palette set

 

      _ps.KeepFocus = true;

      _ps.Visible = true;

    }

  }

}

Here’s the XAML from our WPF user control, which we’ve kept in a separate project (which builds the APNPlugin-MatrixEditorControl.dll module). You’ll notice the ResourceDictionary reference to Theme.xaml, which is the “UX Musing Rough Green” theme – with some minor editing – from the previously mentioned WPF Themes CodePlex project. If you want a more classic look-and-feel, just remove that entry from the UserControl’s resources.

<UserControl x:Class="MatrixEditor.MatrixEditorControl"

  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

  Height="Auto" Width="538">

  <UserControl.Resources>

    <ResourceDictionary Source="Theme.xaml"/>

  </UserControl.Resources>

  <Grid

    Width="{Binding RelativeSource={RelativeSource FindAncestor,

          AncestorType={x:Type UserControl}}, Path=ActualWidth}">

    <StackPanel Background="White">

      <Button

        Name="IdentityButton"

        Height="28"

        Click="IdentityButton_Click">Clear (Identity)</Button>

      <Button

        Name="UCSButton"

        Height="28"

        Click="UCSButton_Click">Get Current UCS</Button>

      <Button

        Name="TransposeButton"

        Height="28"

        Click="TransposeButton_Click">Transpose</Button>

      <DockPanel HorizontalAlignment="Stretch">

        <Label

          Name="DispVectorLabel"

          Height="28"

          Width="53">Vector</Label>

        <TextBox

          Name="DispVectorX"

          Height="35"

          Width="40">5</TextBox>

        <TextBox

          Name="DispVectorY"

          Height="35"

          Width="40">5</TextBox>

        <TextBox

          Name="DispVectorZ"

          Height="35"

          Width="40">5</TextBox>

        <Button

          Name="DispButton"

          Height="28"

          Click="DispButton_Click">Add Displacement</Button>

      </DockPanel>

      <DockPanel HorizontalAlignment="Stretch">

        <Label

          Name="ScaleOriginLabel"

          Height="28"

          Width="53">Origin</Label>

        <TextBox

          Name="ScaleOrigX"

          Height="35"

          Width="40">0</TextBox>

        <TextBox

          Name="ScaleOrigY"

          Height="35"

          Width="40">0</TextBox>

        <TextBox

          Name="ScaleOrigZ"

          Height="35"

          Width="40">0</TextBox>

        <Label

          Name="ScaleFactorLabel"

          Height="28"

          Width="50">Factor</Label>

        <TextBox

          Name="ScaleFactor"

          Height="35"

          Width="40">5</TextBox>

        <Button

          Name="ScaleButton"

          Height="28"

          Click="ScaleButton_Click">Add Scaling</Button>

      </DockPanel>

      <DockPanel HorizontalAlignment="Stretch">

        <Label

          Name="MirrStartLabel"

          Height="28"

          Width="53">Start</Label>

        <TextBox

          Name="MirrStartX"

          Height="35"

          Width="40">10</TextBox>

        <TextBox

          Name="MirrStartY"

          Height="35"

          Width="40">0</TextBox>

        <TextBox

          Name="MirrStartZ"

          Height="35"

          Width="40">0</TextBox>

        <Label

          Name="MirrEndLabel"

          Height="28"

          Width="40">End</Label>

        <TextBox

          Name="MirrEndX"

          Height="35"

          Width="40">10</TextBox>

        <TextBox

          Name="MirrEndY"

          Height="35"

          Width="40">10</TextBox>

        <TextBox

          Name="MirrEndZ"

          Height="35"

          Width="40">0</TextBox>

        <Button

          Name="MirrButton"

          Height="28"

          Click="MirrButton_Click">Add Mirroring</Button>

      </DockPanel>

      <DockPanel HorizontalAlignment="Stretch">

        <Label

          Name="RotOriginLabel"

          Height="28"

          Width="53">Origin</Label>

        <TextBox

          Name="RotOrigX"

          Height="35"

          Width="40">0</TextBox>

        <TextBox

          Name="RotOrigY"

          Height="35"

          Width="40">0</TextBox>

        <TextBox

          Name="RotOrigZ"

          Height="35"

          Width="40">0</TextBox>

        <Label

          Name="RotAxisLabel"

          Height="28"

          Width="40">Axis</Label>

        <TextBox

          Name="RotAxisX"

          Height="35"

          Width="40">0</TextBox>

        <TextBox

          Name="RotAxisY"

          Height="35"

          Width="40">0</TextBox>

        <TextBox

          Name="RotAxisZ"

          Height="35"

          Width="40">1</TextBox>

        <Label

          Name="RotAngleLabel"

          Height="28"

          Width="50">Angle</Label>

        <TextBox

          Name="RotAngle"

          Height="35"

          Width="45">180</TextBox>

        <Button

          Name="RotButton"

          Height="28"

          Click="RotButton_Click">Add Rotation</Button>

      </DockPanel>

      <Separator/>

      <DockPanel>

        <Grid HorizontalAlignment="Center">

          <Grid.ColumnDefinitions>

            <ColumnDefinition Width="Auto" />

            <ColumnDefinition Width="Auto" />

            <ColumnDefinition Width="Auto" />

            <ColumnDefinition Width="Auto" />

          </Grid.ColumnDefinitions>

          <Grid.RowDefinitions>

            <RowDefinition Height="50" />

            <RowDefinition Height="50" />

            <RowDefinition Height="50" />

            <RowDefinition Height="50" />

            <RowDefinition Height="50" />

            <RowDefinition Height="50" />

          </Grid.RowDefinitions>

          <TextBox

            Name="a"

            FontSize="14pt"

            Grid.Column="0"

            Grid.Row="1"

            TextChanged="cell_TextChanged">a</TextBox>

          <TextBox

            Name="b"

            FontSize="14pt"

            Grid.Column="1"

            Grid.Row="1"

            TextChanged="cell_TextChanged">b</TextBox>

          <TextBox

            Name="c"

            FontSize="14pt"

            Grid.Column="2"

            Grid.Row="1"

            TextChanged="cell_TextChanged">c</TextBox>

          <TextBox

            Name="d"

            FontSize="14pt"

            Grid.Column="3"

            Grid.Row="1"

            TextChanged="cell_TextChanged">d</TextBox>

          <TextBox

            Name="e"

            FontSize="14pt"

            Grid.Column="0"

            Grid.Row="2"

            TextChanged="cell_TextChanged">e</TextBox>

          <TextBox

            Name="f"

            FontSize="14pt"

            Grid.Column="1"

            Grid.Row="2"

            TextChanged="cell_TextChanged">f</TextBox>

          <TextBox

            Name="g"

            FontSize="14pt"

            Grid.Column="2"

            Grid.Row="2"

            TextChanged="cell_TextChanged">g</TextBox>

          <TextBox

            Name="h"

            FontSize="14pt"

            Grid.Column="3"

            Grid.Row="2"

            TextChanged="cell_TextChanged">h</TextBox>

          <TextBox

            Name="i"

            FontSize="14pt"

            Grid.Column="0"

            Grid.Row="3"

            TextChanged="cell_TextChanged">i</TextBox>

          <TextBox

            Name="j"

            FontSize="14pt"

            Grid.Column="1"

            Grid.Row="3"

            TextChanged="cell_TextChanged">j</TextBox>

          <TextBox

            Name="k"

            FontSize="14pt"

            Grid.Column="2"

            Grid.Row="3"

            TextChanged="cell_TextChanged">k</TextBox>

          <TextBox

            Name="l"

            FontSize="14pt"

            Grid.Column="3"

            Grid.Row="3"

            TextChanged="cell_TextChanged">l</TextBox>

          <TextBox

            Name="m"

            FontSize="14pt"

            Grid.Column="0"

            Grid.Row="4"

            TextChanged="cell_TextChanged">m</TextBox>

          <TextBox

            Name="n"

            FontSize="14pt"

            Grid.Column="1"

            Grid.Row="4"

            TextChanged="cell_TextChanged">n</TextBox>

          <TextBox

            Name="o"

            FontSize="14pt"

            Grid.Column="2"

            Grid.Row="4"

            TextChanged="cell_TextChanged">o</TextBox>

          <TextBox

            Name="p"

            FontSize="14pt"

            Grid.Column="3"

            Grid.Row="4"

            TextChanged="cell_TextChanged">p</TextBox>

        </Grid>

      </DockPanel>

      <Separator/>

      <DockPanel HorizontalAlignment="Stretch">

        <Button

          Height="28"

          Width="150"

          Name="SelectButton"

          Click="SelectButton_Click">Select Entity >></Button>

        <ComboBox

          Name="PropertyCombo"

          Height="28"

          Width="250"

          IsEnabled="False"

          IsEditable="False">

          <ComboBoxItem>Entire entity</ComboBoxItem>

        </ComboBox>

        <Button

          Name="TransformButton"

          Height="28"

          IsEnabled="False"

          Click="TransformButton_Click"

          DockPanel.Dock="Right"> </Button>

      </DockPanel>

    </StackPanel>

  </Grid>

</UserControl>

Here’s the C# code-behind:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using System.Runtime.InteropServices;

using System.Reflection;

using System.Globalization;

using System.Windows.Controls;

using System.Windows.Media;

using System.Windows;

using System.Text;

using System;

 

namespace MatrixEditor

{

  /// <summary>

  /// Interaction logic for MatrixEditorControl.xaml

  /// </summary>

  ///

  public partial class MatrixEditorControl : UserControl

  {

    #region Member variables / constants

 

    Matrix3d _current; // The current matrix state

    ObjectId _entId;  // The selected entity

    bool _dirty;      // Whether the matrix has been edited

 

    // String to display in property combo

 

    const string entireEntity = "Entire entity";

 

    #endregion

 

    #region P/Invoke declarations

 

    // Win32 call to avoid double-click on entity selection

 

    [DllImport("user32.dll")]

    private static extern IntPtr SetFocus(IntPtr hWnd);

 

    #endregion

 

    #region Constructor

 

    public MatrixEditorControl()

    {

      InitializeComponent();

      SetIdentity();

      ClearPropertyCombo();

      _dirty = false;

    }

 

    #endregion

 

    #region Externally callable protocol

 

    // Called by our external command to set the

    // selected entity

 

    public void SetSelectedEntity(ObjectId id)

    {

      _entId = id;

 

      ClearPropertyCombo();

      PropertyCombo.SelectedIndex = 0;

 

      if (id == ObjectId.Null)

      {

        // Disable the UI, if the ID is null

 

        TransformButton.IsEnabled = false;

        TransformButton.Content = " ";

        PropertyCombo.IsEnabled = false;

      }

      else

      {

        // Enabled the UI

 

        TransformButton.IsEnabled = true;

        PropertyCombo.IsEnabled = true;

        TransformButton.Content = "Transform";

 

        Document doc =

          Autodesk.AutoCAD.ApplicationServices.Application.

          DocumentManager.MdiActiveDocument;

        Transaction tr = doc.TransactionManager.StartTransaction();

        using (tr)

        {

          // Open our object and query its properties and their

          // types

 

          Entity ent = tr.GetObject(id, OpenMode.ForRead) as Entity;

          if (ent != null)

          {

            PropertyInfo[] props = ent.GetType().GetProperties();

            foreach (PropertyInfo prop in props)

            {

              // We currently only transform 3D points and matrices

 

              if ((prop.PropertyType == typeof(Matrix3d) ||

                  prop.PropertyType == typeof(Point3d))

                  && prop.CanWrite)

              {

                PropertyCombo.Items.Add(prop.Name);

              }

            }

          }

          tr.Commit();

        }

      }

    }

 

    #endregion

 

    #region Matrix display functions

 

    // Reset display to the identity matrix

 

    internal void SetIdentity()

    {

      _current = Matrix3d.Identity;

      LoadMatrix(_current);

      LoadMatrix(_current);

    }

 

    // Load a specified matrix in the UI

 

    internal void LoadMatrix(Matrix3d mat)

    {

      double[] data = mat.ToArray();

 

      SetMatrixEntry(a, data[0], true);

      SetMatrixEntry(b, data[1], true);

      SetMatrixEntry(c, data[2], true);

      SetMatrixEntry(d, data[3], true);

      SetMatrixEntry(e, data[4], true);

      SetMatrixEntry(f, data[5], true);

      SetMatrixEntry(g, data[6], true);

      SetMatrixEntry(h, data[7], true);

      SetMatrixEntry(i, data[8], true);

      SetMatrixEntry(j, data[9], true);

      SetMatrixEntry(k, data[10], true);

      SetMatrixEntry(l, data[11], true);

      SetMatrixEntry(m, data[12], true);

      SetMatrixEntry(n, data[13], true);

      SetMatrixEntry(o, data[14], true);

      SetMatrixEntry(p, data[15], true);

    }

 

    // Add (by multiplication) a matrix to the current one

    // and display it in the UI

 

    internal void AddMatrix(Matrix3d mat)

    {

      _current = _current.PreMultiplyBy(mat);

      LoadMatrix(_current);

    }

 

    // Update our current matrix if edited manually

 

    internal void UpdateIfDirty()

    {

      if (_dirty)

      {

        double[] data =

          new double[16]

          {

            Double.Parse(a.Text),

            Double.Parse(b.Text),

            Double.Parse(c.Text),

            Double.Parse(d.Text),

            Double.Parse(e.Text),

            Double.Parse(f.Text),

            Double.Parse(g.Text),

            Double.Parse(h.Text),

            Double.Parse(i.Text),

            Double.Parse(j.Text),

            Double.Parse(k.Text),

            Double.Parse(l.Text),

            Double.Parse(m.Text),

            Double.Parse(n.Text),

            Double.Parse(o.Text),

            Double.Parse(p.Text)

          };

 

        _current = new Matrix3d(data);

        LoadMatrix(_current);

        _dirty = false;

      }

    }

 

    // Truncate a matrix value for display

 

    private string TruncateForDisplay(double value)

    {

      int whole = (int)value;

      double partial = Math.Abs(value - whole);

 

      if (partial < Tolerance.Global.EqualPoint)

        return whole.ToString();

      else

        return value.ToString("F2", CultureInfo.InvariantCulture);

    }

 

    // Set the value of a matrix entry, changing the colour

    // to red, if it has changed

 

    private void SetMatrixEntry(

      TextBox tb, double value, bool truncate

    )

    {

      string content =

        (truncate ? TruncateForDisplay(value) : value.ToString());

      if (tb.Text != content)

      {

        tb.Text = content;

        tb.Foreground = Brushes.Red;

      }

      else

      {

        tb.Foreground = Brushes.Black;

      }

    }

 

    // Get the current matrix as a string,

    // to send as a command argument

 

    internal string GetMatrixString(Matrix3d mat)

    {

      double[] data = mat.ToArray();

      StringBuilder sb = new StringBuilder();

      for (int i = 0; i < data.Length; i++)

      {

        sb.Append(data[i]);

        if (i < data.Length - 1)

          sb.Append(',');

      }

      return sb.ToString();

    }

 

    #endregion

 

    #region Other UI functions

 

    // Clear the property selection combobox

 

    internal void ClearPropertyCombo()

    {

      PropertyCombo.Items.Clear();

      PropertyCombo.Items.Add(entireEntity);

    }

 

    #endregion

 

    #region Button-click events

 

    private void IdentityButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      SetIdentity();

    }

 

    private void UCSButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      _current =

        Autodesk.AutoCAD.ApplicationServices.Application.

        DocumentManager.MdiActiveDocument.Editor.

        CurrentUserCoordinateSystem;

      LoadMatrix(_current);

    }

 

    private void TransposeButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      UpdateIfDirty();

 

      _current = _current.Transpose();

      LoadMatrix(_current);

    }

 

    private void DispButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      UpdateIfDirty();

 

      AddMatrix(

        Matrix3d.Displacement(

          new Vector3d(

            Double.Parse(DispVectorX.Text),

            Double.Parse(DispVectorY.Text),

            Double.Parse(DispVectorZ.Text)

          )

        )

      );

    }

 

    private void ScaleButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      UpdateIfDirty();

 

      AddMatrix(

        Matrix3d.Scaling(

          Double.Parse(ScaleFactor.Text),

          new Point3d(

            Double.Parse(ScaleOrigX.Text),

            Double.Parse(ScaleOrigY.Text),

            Double.Parse(ScaleOrigZ.Text)

          )

        )

      );

    }

 

    private void MirrButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      UpdateIfDirty();

 

      AddMatrix(

        Matrix3d.Mirroring(

          new Line3d(

            new Point3d(

              Double.Parse(MirrStartX.Text),

              Double.Parse(MirrStartY.Text),

              Double.Parse(MirrStartZ.Text)

            ),

            new Point3d(

              Double.Parse(MirrEndX.Text),

              Double.Parse(MirrEndY.Text),

              Double.Parse(MirrEndZ.Text)

            )

          )

        )

      );

    }

 

    private void RotButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      UpdateIfDirty();

 

      AddMatrix(

        Matrix3d.Rotation(

          Double.Parse(RotAngle.Text) * Math.PI / 180.0,

          new Vector3d(

            Double.Parse(RotAxisX.Text),

            Double.Parse(RotAxisY.Text),

            Double.Parse(RotAxisZ.Text)

          ),

          new Point3d(

            Double.Parse(RotOrigX.Text),

            Double.Parse(RotOrigY.Text),

            Double.Parse(RotOrigZ.Text)

          )

        )

      );

    }

 

    private void SelectButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      SetFocus(

        Autodesk.AutoCAD.ApplicationServices.Application.

        MainWindow.Handle

      );

 

      Autodesk.AutoCAD.ApplicationServices.

      Application.DocumentManager.MdiActiveDocument.

      SendStringToExecute(

        "_SELMATENT ", false, false, false

      );

    }

 

    private void TransformButton_Click(

      object sender, RoutedEventArgs e

    )

    {

      Document doc =

        Autodesk.AutoCAD.ApplicationServices.

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      UpdateIfDirty();

 

      ed.SetImpliedSelection(new ObjectId[] { _entId });

      string cmd =

        "_TRANS " +

        (PropertyCombo.Text == entireEntity ?

          " " : PropertyCombo.Text + " ") +

        GetMatrixString(_current) + " ";

      doc.SendStringToExecute(

        cmd, false, false, true

      );

    }

 

    #endregion

 

    #region Other UI events

 

    // A matrix value has been edited manually

 

    private void cell_TextChanged(

      object sender, TextChangedEventArgs e

    )

    {

      // Change the text colour to red and set the dirty flag

 

      TextBox tb = (TextBox)sender;

      tb.Foreground = Brushes.Red;

      _dirty = true;

    }

 

    #endregion

  }

}

Let’s see the application in action. If you load the ADNPlugin-Transformer.dll file using NETLOAD (which relies on ADNPlugin-MatrixEditorControl.dll and WPFToolkit.dll – no need to NETLOAD these supporting DLLs, they just need to be in the same folder), you will then be able to launch the MATRIX command displaying our custom palette:

The top two buttons set (or reset) the current transformation matrix:

• Clear (Identity) sets the contents of our 4x4 matrix to the unit (or identity) matrix, which, when used to transform something, doesn’t change it in any way, but is a great base for applying additional transformations :-)
• Get Current UCS populates the matrix with that used to define the current UCS
  • If you’re in WCS, this will also be the unit matrix

The buttons below these perform operations on the current transformation matrix:

• Transpose (logically enough) transposes the matrix
• Add Displacement adds a translation component to the matrix, as per the specified vector (with a default of X=5, Y=5, Z=5)
• Add Scaling adds a scaling component to the matrix, as per the specified origin and scale factor
• Add Mirroring adds a mirroring component to the matrix using the specified mirror line
• Add Rotation adds a rotation component to the matrix around the specified origin & axis and with the specified angle

The “add” operations actually multiply the current matrix by the newly specified transformation: all this is done using AutoCAD’s Matrix3d class, just as you would do in your own code.

As we apply transformations, the modified cells get highlighted in red. Here’s the result of us adding a scaling (accepting the default argument values) to the unit matrix:

Now let’s add a displacement…

And a rotation…

You’ll notice one of the above numbers has become –5.00: the reason it has been truncated to two decimal places is that it has a decimal part that is greater than the standard tolerance value, so we’ve represented it to 2 decimal places.

Now let’s select a line entity using the Select Entity >> button at the bottom of the palette. This should enable the combo-box to its right and the Transform button to the right of that:

You can see the combo-box defaults to “Entire entity”, but you can also use it to select the entity’s writeable properties of type Matrix3d or Point3d:

Once we’ve selected how we want to apply the transformation to the entity, we can do so via the Transform button. I should probably add that you can edit the cells of the matrix yourself, if you’re feeling confident you’ve grasped what you need of the theory. :-)

That’s about it for this little tool, for now… please give it a spin and let me know what you think. And a big thanks for Jeremy Tammik for providing his feedback prior to our “DevTech Switzerland Xmas Fondue”, this afternoon.

Did not arrive in London

Things were going so well on this year’s DevDays tour. Then, as Jeremy reported on his blog, the best-laid plans of mice and men unravelled, thanks to the severe weather conditions that have been hitting the UK.

Despite the bad news in the weather, yesterday morning, I was still reasonably (foolishly?) optimistic about my own chances of getting to the UK: British Airways had declared my flight still to be operating – mainly as it was the return flight of one of the 4 short-haul flights planned to leave Heathrow yesterday.

By the time I arrived at the airport, though, the flight had been cancelled, along with all others heading to Heathrow. Geneva airport was crowded with passengers trying to get on flights to the UK, so while I made some attempt to get online to rebook (and also left a message with our no-doubt overstretched, UK-based travel agent), I was pretty realistic about my chances of getting there.

I’d really been hoping to make it – despite the weather conditions – as most of the rest of the ADN team due to staff the event were already confirmed to be stuck in Milan until at least Monday morning. In the end our UK-based team members are having to battle on and deliver as much of the content as they can, although as the conditions don’t appear any better, this morning, I’m wondering how many attendees will have actually made it to the event.

Looking on the bright side, I’m going to be able to spend some more time with my family on the lead up to Christmas, as well as reducing the risk of being stuck away from home for the holidays. Oh, and I’ll be able to put the finishing touches on the matrix transformation application, to share that with you all in the next day or two.

A simple command to perform a matrix transformation on an AutoCAD entity using .NET

As promised in the last post and based on the overwhelming feedback in the one before that,  today we’re starting a series on how to transform AutoCAD geometry.

Before developing a fancy modeless GUI to make this really easy, we need a base command that can do the hard work. What’s needed from our basic command is the following:

• Get a single entity from the pickfirst set (which will help us when calling the command from our modeless UI)
  • If there isn’t one selected, ask the user for it
• Get the property name to transform
  • Only for writeable Point3d and Vector3d properties
    • The list of valid properties will be populated in our GUI, so we shouldn’t need much validation
  • If none is entered, we just transform the whole entity
• Get the matrix contents as a comma-delimited string
  • We’ll then decompose it into the 16 doubles required to define a Matrix3d
• Transform the property (or the whole entity) by the provided matrix
  • We will use Reflection to get and set the Point3d/Vector3d property value

To understand some of the underlying concepts, let’s talk a little about transformation matrices.

We need 4 x 4 matrices when working in 3D space to allow us to perform a full range of transformations: translation, rotation, scaling, mirroring and projection. We could achieve some of these using 3 x 3 matrices, but some of these – particular translation, but probably some of the others (I’m not 100% certain of the specifics) – need the additional cells.

We’ll be looking into different transformation matrix types in more detail when we have a simple UI to play around with them, but for now let’s focus on a simple scaling matrix.

2	0	0	0
0	2	0	0
0	0	2	0
0	0	0	1

When we apply this transformation to an entity, it is basically used to multiply the relevant properties (and basically scales them by a factor of 2).

Let’s see what that means by applying this scaling transformation to the 3D point (5, 5, 0), which could be the centre point of a circle (for instance). We need to add a unit entry (1) to the point, to make it compatible with a 4 x 4 matrix.

2	0	0	0		5
0	2	0	0	*	5
0	0	2	0		0
0	0	0	1		1

Now if we follow the rules of matrix multiplication, we can see that our resultant point is calculated like this:

a	b	c	d		r		a*r + b*s + c*t + d*u
e	f	g	h	*	s	=	e*r + f*s + g*t + h*u
i	j	k	l		t		i*r + j*s + k*t + l*u
n	o	p	q		u		n*r + o*s + p*t + q*u

This page has a nice graphical representation of multiplying a matrix with a vector.

Which means for us, specifically:

2	0	0	0		5		10 + 0 + 0 + 0
0	2	0	0	*	5	=	0 + 10 + 0 + 0
0	0	2	0		0		0 + 0 + 0 + 0
0	0	0	1		1		0 + 0 + 0 + 1

And so our transformed point – which is the top three values of the resultant 4-cell matrix – is (10, 10, 0).

Now let’s see the C# code to transform an entity by a user-specified matrix:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Runtime;

using System.Reflection;

 

namespace Transformer

{

  public class Commands

  {

    [CommandMethod("TRANS", CommandFlags.UsePickSet)]

    static public void TransformEntity()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      // Our selected entity (only one supported, for now)

 

      ObjectId id;

 

      // First query the pickfirst selection set

 

      PromptSelectionResult psr = ed.SelectImplied();

      if (psr.Status != PromptStatus.OK || psr.Value == null)

      {

        // If nothing selected, ask the user

 

        PromptEntityOptions peo =

          new PromptEntityOptions(

            "\nSelect entity to transform: "

          );

        PromptEntityResult per = ed.GetEntity(peo);

        if (per.Status != PromptStatus.OK)

          return;

        id = per.ObjectId;

      }

      else

      {

        // If the pickfirst set has one entry, take it

 

        SelectionSet ss = psr.Value;

        if (ss.Count != 1)

        {

          ed.WriteMessage(

            "\nThis command works on a single entity."

          );

          return;

        }

        ObjectId[] ids = ss.GetObjectIds();

        id = ids[0];

      }

 

      PromptResult pr = ed.GetString("\nEnter property name: ");

      if (pr.Status != PromptStatus.OK)

        return;

 

      string prop = pr.StringResult;

 

      // Now let's ask for the matrix string

 

      pr = ed.GetString("\nEnter matrix values: ");

      if (pr.Status != PromptStatus.OK)

        return;

 

      // Split the string into its individual cells

 

      string[] cells = pr.StringResult.Split(new char[] { ',' });

      if (cells.Length != 16)

      {

        ed.WriteMessage("\nMust contain 16 entries.");

        return;

      }

 

      try

      {

        // Convert the array of strings into one of doubles

 

        double[] data = new double[cells.Length];

        for (int i = 0; i < cells.Length; i++)

        {

          data[i] = double.Parse(cells[i]);

        }

 

        // Create a 3D matrix from our cell data

 

        Matrix3d mat = new Matrix3d(data);

 

        // Now we can transform the selected entity

 

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          Entity ent =

            tr.GetObject(id, OpenMode.ForWrite)

            as Entity;

          if (ent != null)

          {

            bool transformed = false;

 

            // If the user specified a property to modify

 

            if (!string.IsNullOrEmpty(prop))

            {

              // Query the property's value

 

              object val =

                ent.GetType().InvokeMember(

                  prop, BindingFlags.GetProperty, null, ent, null

                );

 

              // We only know how to transform points and vectors

 

              if (val is Point3d)

              {

                // Cast and transform the point result

 

                Point3d pt = (Point3d)val,

                        res = pt.TransformBy(mat);

 

                // Set it back on the selected object

 

                ent.GetType().InvokeMember(

                  prop, BindingFlags.SetProperty, null,

                  ent, new object[] { res }

                );

                transformed = true;

              }

              else if (val is Vector3d)

              {

                // Cast and transform the vector result

 

                Vector3d vec = (Vector3d)val,

                        res = vec.TransformBy(mat);

 

                // Set it back on the selected object

 

                ent.GetType().InvokeMember(

                  prop, BindingFlags.SetProperty, null,

                  ent, new object[] { res }

                );

                transformed = true;

              }

            }

 

            // If we didn't transform a property,

            // do the whole object

 

            if (!transformed)

              ent.TransformBy(mat);

          }

          tr.Commit();

        }

      }

      catch (Autodesk.AutoCAD.Runtime.Exception ex)

      {

        ed.WriteMessage(

          "\nCould not transform entity: {0}", ex.Message

        );

      }

    }

  }

}

Now let’s use the TRANS command to transform a couple of entities:

We’ll use TRANS to apply the above scaling transformation matrix to the whole circle and then to the EndPoint of the line:

Command: TRANS

Select entity to transform: <selected the circle>

Enter property name:

Enter matrix values: 2,0,0,0,0,2,0,0,0,0,2,0,0,0,0,1

Command: TRANS

Select entity to transform: <selected the line>

Enter property name: EndPoint

Enter matrix values: 2,0,0,0,0,2,0,0,0,0,2,0,0,0,0,1

With these results:

I understand this is quite a tricky topic, so I’d appreciate your feedback: does this initial explanation help, at all? Does the level of detail work for you?

In the coming posts we’ll be looking at more complex transformation matrices – and using a GUI to play around with them – but hopefully this introductory post is a reasonably helpful start.

Arrived in München

I’ve arrived in Munich for our German DevDay + DevLab. There’s lots of snow, but luckily I didn’t get delayed: I was a touch paranoid after my trip to AU, and then having to fly two legs to get here.

Therein lies a story: it’s not usually needed to take two planes to get from Switzerland to Munich, of course, but I had a 30-minute flight from Geneva to Zurich before connecting to a 50-minute flight form Zurich to Munich. As far as I recall this was the most cost-effective option when I booked the flight. My home is actually a bit closer to Geneva than Zurich, but there’s not that much in it: despite this I ended up choosing to Geneva rather than taking the direct flight in Zurich, mainly because I only lost about 45 minutes of my day doing so, and it seemed easier that possibly having to explain why I didn’t take the first leg. And it all turned out fine, but was probably a bit more complicated that I needed, especially given the inclement weather. At least I fly directly to Geneva on the way home.

Thanks to everyone who responded to yesterday’s request for comments – please continue to do so, if you have an opinion and haven’t yet expressed it. I will just say that you need to take Jeremy’s comment with a pinch of salt: yes, he may need to relearn mathematics via Wikipedia when he needs something, but then he does have an advanced degree in mathematics, so his foundation is a little higher than the rest of us. ;-)

Anyway, I’m now convinced this is something that’s worth doing and I’m certainly planning to address it within the context of AutoCAD: I’m thinking about developing some kind of tool that allows you to experiment with geometry – whether whole entities or their modifiable properties – by visualizing and applying matrix transformations. And we’ll look at the underlying theory as we go through the steps of creating the tool.

The first post will implement a simple command to transform an entity by asking the user to enter the matrix contents via the command-line. In due course this will get wrapped with a nice palette-based UI that will generate matrices based on user-input and then fire off use the previously-defined command to execute the modification. And at some point I’ll throw reflection into the mix, querying the writeable Point3d and Vector3d properties of the selected entity and allowing the user to transform those instead of the whole object. Sounds like fun? :-)

Enter The Matrix

One AU evening at the bar, I was chatting to a couple of developers who suggested covering some fundamental mathematics on this blog: their respective career paths had not involved any formal (or perhaps recent) studies of certain important areas of mathematics, especially related to core linear algebra concepts such as matrix multiplication.

Part of me said, “what a great idea”, another part said “I wonder what resources are already out there” and the last said “oh man, I don’t remember how all that stuff actually works”. :-)

Before I start dusting off some of that well-buried geometrical knowledge, I thought I’d ask a couple of questions of this blog’s readership:

1. Does this sound like a useful topic to anyone else?
2. For those who have had to work through such topics in recent (enough) memory, do you recommend any particular resources to use? (If there’s something out there that serves the purpose well – even if it doesn’t address the concepts with respect to AutoCAD’s geometry library – that would save some trouble.)

Please post a comment if you have anything to share on this topic.

Some content from AU 2010

As many of you may now be aware, much of the content recorded at this year’s Autodesk University is now available on the AU website.

You’ll find the recording of my AU Virtual session, “Getting to Know the AutoCAD® Plug-ins of the Month”, as well as material from the two physical sessions I presented, “Point Clouds on a Shoestring” and “Integrate F# into Your C# or VB.NET Application for an 8x Performance Boost”. In fact, much to my surprise, the “Point Clouds on a Shoestring” session (which turned out to be my highest-rated session) ended up being recorded, and can be watched online or downloaded and watched offline. I had no idea that was happening, but I’m very happy it’s up there. Thinking back, it does explain a couple of strange interactions I had with the technical staff supporting the event, who were clearly aware the recording was going to happen. :-)

I also participated in a couple of panel sessions: “AutoCAD® APIs: Meet the Experts” (which was recorded) and “Ask the AutoCAD® Programming Gurus” (which was not).

On a related note, Stephen Preston, our DevTech Americas Manager, recorded his two classes from AU using Camtasia and has posted them as DevTV sessions for your viewing pleasure:

AutoCAD® .NET: Practical Examples of Customizing AutoCAD Entity Behavior	View	Download (53.1MB)	Handout & Samples (7.95MB)
Creating Geometric and Dimensional Constraints Using the AutoCAD® .NET API	View	Download (47.4MB)	Handout & Samples (864KB)

Stephen went ahead and recorded the first one – his AU Virtual class – because the session recording unfortunately missed some important slides, switching instead to the video feed of his face, but he also recorded it before he realised the content would be posted to the AU website. The second of the two was not recorded during the event, so it’s particularly useful that he’s taken the time to get that captured and posted. For more information on Stephen’s second session, you can also see the information posted on the AU website.

Enjoy! :-)

Update

I wasn’t sure who exactly was eligible to view the content on AU Online, but Stephen pointed out a way for me to check. It seems that the material is only available to Autodesk Subscription customers, AU 2010 conference attendees and AU 2010 Virtual Premier registrants. Stephen’s content is completely public, however.

December’s Plugin of the Month live on Autodesk Labs: QR Codes for AutoCAD

As promised and reported on, and then announced by Scott on his blog, the QR Codes application for AutoCAD is now live on Autodesk Labs as December’s Plugin of the Month. You may have seen my original implementation, but it’s come a long way thanks to the efforts of Augusto Gonçalves, a member of DevTech based in São Paulo.

While I had developed the original implementation to create and embed raster images using the Google Chart API, Augusto extended that implementation to create native hatches for QR Codes. And while my implementation focused on a command-line UI, Augusto implemented a dialog-based GUI to complement it. Both the command-line and dialog-based UIs can now be used to create either native (i.e. hatch) or online (i.e. raster image) QR Codes.

Download it and give it a try! And be sure to check out the accompanying source project, of course. :-)

Once loaded, you can use the QRGEN command (and it’s command-line counterpart, –QRGEN) to create a QR Code representing one of the following content types:

• Calendar
• Contact
• Email
• Geolocation
• Phone
• Text
• Url

As we save the source data along with the hatch or raster image as XData, they can then be edited (even in later editing sessions) using QRED or –QRED.

Here’s an example of my contact information embedded in native (left) and online (right) QR Codes inside AutoCAD:

Now if you try and scan the left-hand image, you’ll probably fail: most QR Codes are black on a white background, while this is the opposite. That said, if you print them – or use a white background without a grid – then they should both work well:

You’ll notice the patterns are different: it’s like the Google Chart implementation uses a different error correction level (as described here and here), which would go some way to explaining that.

I’m really impressed with how Augusto as managed to make a complex QR Code out of a single solid-filled hatch: I had always imagined having to create lots of solids to do this, but apparently it wasn’t needed. Neat stuff.

As ever, please let us know what you think by posting a comment or dropping us an email.

Jigging an AutoCAD polyline with arc segments using .NET

I was just easing back into post-AU work – dealing with my email backlog and thinking about possible blog posts for the week – when I received a very welcome email from Philippe Leefsma, a member of the DevTech team based in Prague. Philippe had a bit of time to spare during our annual DevDays tour and decided to polish up a sample he’d been working on for posting. It extends a post of mine from four years ago (I can’t believe it’s been that long, but anyway), which shows how to jig a polyline with keywords. Philippe adjusted the code to modify the bulge factor of the current arc segment dynamically based on the cursor position – very much as the standard PLINE command does, in fact.

Here’s the C# code, with a few minor – mostly formatting – modifications from my side:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Runtime;

using System;

 

namespace PolylineJig

{

  class JigUtils

  {

    // Custom ArcTangent method, as the Math.Atan

    // doesn't handle specific cases

 

    public static double Atan(double y, double x)

    {

      if (x > 0)

        return Math.Atan(y / x);

      else if (x < 0)

        return Math.Atan(y / x) - Math.PI;

      else  // x == 0

      {

        if (y > 0)

          return Math.PI;

        else if (y < 0)

          return -Math.PI;

        else // if (y == 0) theta is undefined

          return 0.0;

      }

    }

 

    // Computes Angle between current direction

    // (vector from last vertex to current vertex)

    // and the last pline segment

 

    public static double ComputeAngle(

      Point3d startPoint, Point3d endPoint,

      Vector3d xdir, Matrix3d ucs

    )

    {

      Vector3d v =

        new Vector3d(

          (endPoint.X - startPoint.X) / 2,

          (endPoint.Y - startPoint.Y) / 2,

          (endPoint.Z - startPoint.Z) / 2

        );

 

      double cos = v.DotProduct(xdir);

      double sin =

        v.DotProduct(

          Vector3d.ZAxis.TransformBy(ucs).CrossProduct(xdir)

        );

 

      return Atan(sin, cos);

    }

  }

 

  public class BulgePolyJig : EntityJig

  {

    Point3d _tempPoint;

    Plane _plane;

    bool _isArcSeg = false;

    bool _isUndoing = false;

    Matrix3d _ucs;

 

    public BulgePolyJig(Matrix3d ucs) : base(new Polyline())

    {

      _ucs = ucs;

      Vector3d normal = Vector3d.ZAxis.TransformBy(ucs);

      _plane = new Plane(Point3d.Origin, normal);

      Polyline pline = Entity as Polyline;

      pline.SetDatabaseDefaults();

      pline.Normal = normal;

      AddDummyVertex();

    }

 

    protected override SamplerStatus Sampler(JigPrompts prompts)

    {

      JigPromptPointOptions jigOpts = new JigPromptPointOptions();

 

      jigOpts.UserInputControls =

        (UserInputControls.Accept3dCoordinates |

        UserInputControls.NullResponseAccepted |

        UserInputControls.NoNegativeResponseAccepted);

 

      _isUndoing = false;

 

      Polyline pline = Entity as Polyline;

 

      if (pline.NumberOfVertices == 1)

      {

        // For the first vertex, just ask for the point

 

        jigOpts.Message = "\nSpecify start point: ";

      }

      else if (pline.NumberOfVertices > 1)

      {

        string msgAndKwds =

          (_isArcSeg ?

            "\nSpecify endpoint of arc or [Line/Undo]: " :

            "\nSpecify next point or [Arc/Undo]: "

          );

 

        string kwds = (_isArcSeg ? "Line Undo" : "Arc Undo");

 

        jigOpts.SetMessageAndKeywords(msgAndKwds, kwds);

      }

      else

        return SamplerStatus.Cancel; // Should never happen

 

      // Get the point itself

 

      PromptPointResult res = prompts.AcquirePoint(jigOpts);

 

      if (res.Status == PromptStatus.Keyword)

      {

        if (res.StringResult.ToUpper() == "ARC")

          _isArcSeg = true;

        else if (res.StringResult.ToUpper() == "LINE")

          _isArcSeg = false;

        else if (res.StringResult.ToUpper() == "UNDO")

          _isUndoing = true;

 

        return SamplerStatus.OK;

      }

      else if (res.Status == PromptStatus.OK)

      {

        // Check if it has changed or not (reduces flicker)

 

        if (_tempPoint == res.Value)

          return SamplerStatus.NoChange;

        else

        {

          _tempPoint = res.Value;

          return SamplerStatus.OK;

        }

      }

 

      return SamplerStatus.Cancel;

    }

 

    protected override bool Update()

    {

      // Update the dummy vertex to be our 3D point

      // projected onto our plane

 

      Polyline pl = Entity as Polyline;

 

      if (_isArcSeg)

      {

        Point3d lastVertex =

          pl.GetPoint3dAt(pl.NumberOfVertices - 2);

 

        Vector3d refDir;

 

        if (pl.NumberOfVertices < 3)

          refDir = new Vector3d(1.0, 1.0, 0.0);

        else

        {

          // Check bulge to see if last segment was an arc or a line

 

          if (pl.GetBulgeAt(pl.NumberOfVertices - 3) != 0)

          {

            CircularArc3d arcSegment =

              pl.GetArcSegmentAt(pl.NumberOfVertices - 3);

 

            Line3d tangent = arcSegment.GetTangent(lastVertex);

 

            // Reference direction is the invert of the arc tangent

            // at last vertex

 

            refDir = tangent.Direction.MultiplyBy(-1.0);

          }

          else

          {

            Point3d pt =

              pl.GetPoint3dAt(pl.NumberOfVertices - 3);

 

            refDir =

              new Vector3d(

                lastVertex.X - pt.X,

                lastVertex.Y - pt.Y,

                lastVertex.Z - pt.Z

              );

          }

        }

 

        double angle =

          JigUtils.ComputeAngle(

            lastVertex, _tempPoint, refDir, _ucs

          );

 

        // Bulge is defined as tan of one fourth of included angle

        // Need to double the angle since it represents the included

        // angle of the arc

        // So formula is: bulge = Tan(angle * 2 * 0.25)

 

        double bulge = Math.Tan(angle * 0.5);

 

        pl.SetBulgeAt(pl.NumberOfVertices - 2, bulge);

      }

      else

      {

        // Line mode. Need to remove last bulge if there was one

 

        if (pl.NumberOfVertices > 1)

          pl.SetBulgeAt(pl.NumberOfVertices - 2, 0);

      }

 

      pl.SetPointAt(

        pl.NumberOfVertices - 1, _tempPoint.Convert2d(_plane)

      );

 

      return true;

    }

 

    public bool IsUndoing

    {

      get

      {

        return _isUndoing;

      }

    }

 

    public void AddDummyVertex()

    {

      // Create a new dummy vertex... can have any initial value

 

      Polyline pline = Entity as Polyline;

      pline.AddVertexAt(

        pline.NumberOfVertices, new Point2d(0, 0), 0, 0, 0

      );

    }

 

    public void RemoveLastVertex()

    {

      Polyline pline = Entity as Polyline;

 

      // Let's first remove our dummy vertex   

 

      if (pline.NumberOfVertices > 0)

        pline.RemoveVertexAt(pline.NumberOfVertices - 1);

 

      // And then check the type of the last segment

 

      if (pline.NumberOfVertices >= 2)

      {

        double blg = pline.GetBulgeAt(pline.NumberOfVertices - 2);

        _isArcSeg = (blg != 0);

      }

    }

 

    public void Append()

    {

      Database db = HostApplicationServices.WorkingDatabase;

 

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        BlockTable bt =

          tr.GetObject(

            db.BlockTableId, OpenMode.ForRead

          ) as BlockTable;

        BlockTableRecord btr =

          tr.GetObject(

            bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite

          ) as BlockTableRecord;

 

        btr.AppendEntity(this.Entity);

        tr.AddNewlyCreatedDBObject(this.Entity, true);

        tr.Commit();

      }

    }

 

    [CommandMethod("BPJIG")]

    public static void RunBulgePolyJig()

    {

      Document doc = Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      BulgePolyJig jig =

        new BulgePolyJig(ed.CurrentUserCoordinateSystem);

 

      while (true)

      {

        PromptResult res = ed.Drag(jig);

 

        switch (res.Status)

        {

          // New point was added, keep going

 

          case PromptStatus.OK:

            jig.AddDummyVertex();

            break;

 

          // Keyword was entered

 

          case PromptStatus.Keyword:

            if (jig.IsUndoing)

              jig.RemoveLastVertex();

            break;

 

          // If the jig completed successfully, add the polyline

 

          case PromptStatus.None:

            jig.RemoveLastVertex();

            jig.Append();

            return;

 

          // User cancelled the command, get out of here

          // and don't forget to dispose the jigged entity

 

          default:

            jig.Entity.Dispose();

            return;

        }

      }

    }

  }

}

Here’s the BPJIG command in action, jigging a polyline with arc segments:

Now it must be noted that this implementation is some way from re-implementing the full PLINE command – for those of you who like to re-invent the wheel ;-) - but it should provide some idea of how to allow users to input bulge factors for polyline segments that are being jigged by your custom commands.

Thanks, Philippe! :-)

Back from AU 2010

I was hoping to post during the week from Las Vegas, but it didn’t end up happening. My time just bled away between the various classes I recorded/ presented/co-paneled and the time spent catching up with old friends and making new ones – mainly from among the various people who took the chance to provide greatly appreciated feedback regarding this blog.

All in all it was a great week – as it always is – but it wasn’t all smooth sailing: my AU Virtual session on our Plugins of the Month – which I’d struggled to get into Vegas to record – was among many that were plagued by technical problems. I have a sneaking suspicion that my sessions didn’t end up having anyone successfully connect to for the full duration – whether you were able to or not, I’d appreciate hearing your comments on the experience. And please accept my sincere apologies for any inconvenience: while outside my control, I do feel very bad for anyone who wasted time on this. I have no doubt that next year will be much better, but in the meantime I’m going to look into the “on demand” experience and see whether it’s worth me posting a repeat session recorded using Camtasia.

The physical classes all went much better, thankfully. I haven’t seen the feedback, as yet, but I certain got the impression that many of the people in the room for both my classes (“CP322-2 - Integrate F# into Your C# or VB.NET Application for an 8x Performance Boost” and “AC427-4 - Point Clouds on a Shoestring”) seemed to find them valuable. And big thanks to our friends at Eye-Fi for providing two Connect X2 and two Pro X2 cards as competition prizes.

One of the highlights of the event for me was seeing and getting to play around with the upcoming version of Photo Scene Editor (codenamed Caipi). The development team has integrated some incredible meshing technology which is going to be revolutionary: many people in the industry have been struggling to get this kind of capability via convoluted routes, and this will make it really easy.

As an example, here’s another “capture” of my head, this time taken from just 15 images. I used this example in my class to demonstrate some of the inherent issues with capturing shiny/reflective surfaces ;-), but I know the results would have been better if we’d added a few overhead shots.

It should be noted that this is not a visualization created using splats: this is a properly textured mesh! Turning off the textures displays the underlying mesh:

You’ll be able to export the mesh as OBJ, DWG, DWF, FBX and a number of other formats.

Once you have a mesh, the sky’s the limit: while I was in the AU exhibit hall members of the Labs team were working to make a mesh watertight so it could be 3D-printed. Fantastic stuff.

This version of Photo Scene Editor is likely to be posted in a few months: I’ll certainly report back when it’s available.