Through the Interface

November’s Plugin of the Month live on Autodesk Labs: ScriptPro 2.0 for AutoCAD

As mentioned previously, Viru Aithal, from DevTech India, has been working hard on a replacement for the venerable ScriptPro tool. I’m delighted to say that it’s now ready, and is live on Autodesk Labs as November’s Plugin of the Month.

Viru took the codebase he developed for the DWF/PDF Batch Publish tool and created ScriptPro 2.0, written from the ground up in C# and developed without any dependency on a specific AutoCAD version. Viru’s approach uses the equivalent of late binding to call into AutoCAD through COM and so doesn’t require a specific AutoCAD Type Library. Which means the tool should also work for future versions of AutoCAD: there’s no longer any need to wait for an update to the tool. And one advantage of being written in a .NET language is that the application works as well on 64-bit platforms as it does on 32-bit ones (a historical frustration of ScriptPro users).

ScriptPro 2.0 has a new project format – with the file extension .BPL (for Batch Process List). While it can load old ScriptPro projects (.SCP), it doesn’t yet have perfect feature parity – there are some ScriptPro-specific keywords that have not yet been implemented in the 2.0 release, but (providing we hear it’s important to do so) we’ll get there.

The tool has a ribbon UI – built using WPF – but the bulk of the functionality is packaged up in a WinForms User Control and hosted by the WPF app (me may yet move the whole thing to WPF, in time). Here’s the new UI:

And the best thing is that – as a Plugin of the Month – it comes with the complete source code for you to dig into and extend. Be sure to take a look at this very exciting new tool and let us know what you think.

Automatically cropping a bitmap (more quickly)

I mentioned in the last post that I was looking to optimise my approach for automatic cropping of an image. It turns out that using Bitmap.LockBits() and the corresponding UnlockBits() does indeed help, although I haven’t run any actual benchmarks to measure the difference in the two approaches. The disadvantage of this approach is that you’re a bit more down “in the weeds” when it comes to accessing the raw data – you have to support different raw image formats, for instance (and it may well be that I’ve missed some important ones – it’s only really by chance that I realised I would receive two different bitmap formats, depending on the colour depth of the display).

Here’s the optimised version of our Crop() function (called OptiCrop() ;-) which makes use of this approach. I’ve added a GetPixel() helper to encapsulate some of the low-level messiness, especially when it comes to reading 16- and 32-bit colour bitmaps.

  Public Shared Function GetPixel( _

    ByVal bd As BitmapData, _

    ByVal pf As PixelFormat, _

    ByVal x As Integer, ByVal y As Integer) As Color

 

    ' A counter and the RGB values of our color

 

    Dim idx, R, G, B As Integer

 

    If pf = PixelFormat.Format16bppRgb565 Then

 

      ' Variables for the raw bytes

 

      Dim bt1, bt2 As Byte

 

      ' Our pixels span 2 bytes - read them in

 

      idx = (bd.Stride * y) + (2 * x)

      bt1 = Marshal.ReadByte(bd.Scan0, idx)

      bt2 = Marshal.ReadByte(bd.Scan0, idx + 1)

 

      ' The first five bits define R

 

      R = ((bt1 And 245) >> 3) * 255 / 31

 

      ' The next 6 define G

 

      G = (((bt1 And 7) << 3) + ((bt2 And 224) >> 5)) * 255 / 63

 

      ' And the last 5 define B

 

      B = (bt2 And 31) * 255 / 31

 

    ElseIf pf = PixelFormat.Format32bppRgb Then

 

      ' Our pixels span 4 bytes - only the first 3 are used

 

      idx = (bd.Stride * y) + (4 * x)

      R = Marshal.ReadByte(bd.Scan0, idx)

      G = Marshal.ReadByte(bd.Scan0, idx + 1)

      B = Marshal.ReadByte(bd.Scan0, idx + 2)

 

    End If

 

    Return Color.FromArgb(R, G, B)

 

  End Function

 

  Public Shared Function OptiCrop( _

    ByVal b As Bitmap, ByVal bg As Color) As Bitmap

 

    ' We only support 16- and 32-bit color bitmap encoding

 

    If b.PixelFormat <> PixelFormat.Format16bppRgb565 And _

      b.PixelFormat <> PixelFormat.Format32bppRgb Then

      Return b

    End If

 

    ' Variables for the area to crop down to

 

    Dim left As Integer = b.Width

    Dim top As Integer = b.Height

    Dim right As Integer = 0

    Dim bottom As Integer = 0

 

    ' Indeces and the current pixel

 

    Dim x, y As Integer

    Dim c As Color

 

    ' Lock the bitmap's memory for reading

 

    Dim bd As BitmapData = _

      b.LockBits( _

        New Rectangle(New Point(), b.Size), _

      ImageLockMode.ReadOnly, b.PixelFormat)

 

    If bg = Nothing Then

 

      ' If we don't have a background passed in, get the four

      ' corners' colors and find the most common of them

 

      Dim cols() As Color = { _

        GetPixel(bd, b.PixelFormat, 0, 0), _

        GetPixel(bd, b.PixelFormat, 0, b.Height - 1), _

        GetPixel(bd, b.PixelFormat, b.Width - 1, 0), _

        GetPixel(bd, b.PixelFormat, b.Width - 1, b.Height - 1)}

 

      bg = MostCommonColor(cols)

 

    End If

 

    ' Loop through each pixel

 

    For y = 0 To bd.Height - 1

      For x = 0 To bd.Width - 1

        c = GetPixel(bd, b.PixelFormat, x, y)

 

        ' If it's not the same as the background color

 

        If Not SameColor(c, bg) Then

 

          ' Then we update our variables, as appropriate

 

          If x < left Then left = x

          If y < top Then top = y

          If x > right Then right = x

          If y > bottom Then bottom = y

        End If

      Next x

    Next y

 

    ' Unlock the bitmap's memory

 

    b.UnlockBits(bd)

 

    ' Now calculate the dimensions of the cropped output

 

    Dim width As Integer = (right - left)

    Dim height As Integer = (bottom - top)

 

    ' Add a buffer of 5% of the largest dimension (a little padding)

 

    Dim buffer As Integer = Math.Max(width, height) * 0.05

    width += 2 * buffer

    height += 2 * buffer

 

    ' Create the new bitmap and the graphics object to draw to it

 

    Dim cropped As New Bitmap(width, height)

    Dim gfx As Graphics = Graphics.FromImage(cropped)

    Using gfx

 

      ' Set the color of the bitmap to our background

 

      gfx.Clear(bg)

 

      ' Draw the portion of the original image that we want to

      ' the new bitmap

 

      gfx.DrawImage( _

        b, New Rectangle(buffer, buffer, width, height), _

        New Rectangle(left, top, width, height), _

        GraphicsUnit.Pixel)

    End Using

 

    Return cropped

 

  End Function

I’ve made a number of other changes in this version, which could/should also apply to the prior one: when no items are in the list, the preview blanks (and shrinks). I’ve extracted the image-related code into a separate file (leaving the Crop() function alongside OptiCrop(), so you can switch between them to see if you can spot the performance difference or even run your own benchmarks).

I’ve also added a check for “invalid” clipboard entries… the information AutoCAD places on the clipboard is not valid between sessions. So if you ran COPYCLIP before restarting AutoCAD and launching the CLIPBOARD command, you would previously have seen something there in the list, before you’ve COPYCLIPped anything in the new session. That doesn’t mean it’s of any use: the temporary DWG file the data relies on has been deleted when the previous AutoCAD session closed. So I implemented a little check to get the path to this temporary drawing and check whether it’s actually there before adding the item to the list. This same function will also help for when we implement the “Export to DWG” command in the next post.

Anyway, here’s the updated project. Please post a comment if you are comparing the two versions and see a performance difference or not. And be sure also to let me know if you hit any problems, of course.

Automatically cropping a bitmap (slowly)

I received a few comments by email and otherwise regarding the preview capability added to the Clipboard Manager Plugin of the Month in the last post. Basically it’s useful, but only to a point: the bitmap created on the clipboard is the same size as AutoCAD’s screen, with the copied objects in their location relative to the screen. This means that if you’re working on a drawing like this:

And you want to copy the leader to the left of the cursor to the clipboard, the preview you’ll end up with will be something like this:

Which – when scaled down to be placed at the bottom of a palette window – makes it very hard to see the geometry.

This feedback prompted me to think about auto-cropping the preview bitmap, so that we effectively “zoom in” on the geometry.

It turned out to be relatively straightforward to create a basic implementation. We loop through each pixel and check it against the background colour: if it’s not the same then we check to see whether it’s the left-/right-/bottom-/top-most, and, if so, we store it’s x and/or y coordinate to help define the limits of the cropped area.

Here are the helper functions I created to do this (in VB.NET, as that’s what the Clipboard Manager was originally written in):

  Function SameColor(ByVal a As Color, ByVal b As Color) As Boolean

    Return (a.R = b.R And a.G = b.G And a.B = b.B)

  End Function

 

  Function MostCommonColor(ByVal cols() As Color) As Color

 

    ' Use a dictionary to count our colors

 

    Dim cd As Dictionary(Of Color, Integer) = _

      New Dictionary(Of Color, Integer)

 

    ' Loop through the array, adding them one by one

 

    For Each col In cols

 

      If cd.ContainsKey(col) Then

        cd.Item(col) += 1

      Else

        cd.Add(col, 1)

      End If

    Next

 

    ' Now go through the dictionary and get the

    ' most popular color

 

    Dim max As Integer = 0

    Dim mostCommon As Color = Color.Black

 

    For Each kv In cd

      If kv.Value > max Then

        max = kv.Value

        mostCommon = kv.Key

      End If

    Next

 

    Return mostCommon

 

  End Function

 

  Function Crop(ByVal b As Bitmap, ByVal bg As Color) As Bitmap

 

    ' Variables for the area to crop down to

 

    Dim left As Integer = b.Width

    Dim top As Integer = b.Height

    Dim right As Integer = 0

    Dim bottom As Integer = 0

 

    ' Indeces and the current pixel

 

    Dim x, y As Integer

    Dim c As Color

 

    If bg = Nothing Then

 

      ' If we don't have a background passed in, get the four

      ' corners' colors and find the most common of them

 

      Dim cols() As Color = { _

        b.GetPixel(0, 0), _

        b.GetPixel(0, b.Height - 1), _

        b.GetPixel(b.Width - 1, 0), _

        b.GetPixel(b.Width - 1, b.Height - 1)}

 

      bg = MostCommonColor(cols)

 

    End If

 

    ' Loop through each pixel

 

    For y = 0 To b.Height - 1

      For x = 0 To b.Width - 1

        c = b.GetPixel(x, y)

 

        ' If it's not the same as the background color

 

        If Not SameColor(c, bg) Then

 

          ' Then we update our variables, as appropriate

 

          If x < left Then left = x

          If y < top Then top = y

          If x > right Then right = x

          If y > bottom Then bottom = y

        End If

      Next x

    Next y

 

    ' Now calculate the dimensions of the cropped output

 

    Dim width As Integer = (right - left)

    Dim height As Integer = (bottom - top)

 

    ' Add a buffer of 5% of the largest dimension (a little padding)

 

    Dim buffer As Integer = Math.Max(width, height) * 0.05

    width += 2 * buffer

    height += 2 * buffer

 

    ' Create the new bitmap and the graphics object to draw to it

 

    Dim cropped As New Bitmap(width, height)

    Dim gfx As Graphics = Graphics.FromImage(cropped)

    Using gfx

 

      ' Set the color of the bitmap to our background

 

      gfx.Clear(bg)

 

      ' Draw the portion of the original image that we want to

      ' the new bitmap

 

      gfx.DrawImage( _

        b, New Rectangle(buffer, buffer, width, height), _

        New Rectangle(left, top, width, height), _

        GraphicsUnit.Pixel)

    End Using

 

    Return cropped

 

  End Function

One approach that was a little different: assuming no background colour is specified – which we could do, but I didn’t want to get the preferences object from AutoCAD and introduce a COM dependency on the project – we get the colours of the four corner pixels and then count the most popular. Unless very unlucky this will usually be the background color (and if we are, indeed, unlucky the image will simply not be cropped).

Now, overall, this approach to reading bitmap data is *slow* – it takes about a second to crop a preview using the above code on my system – but it does prove the concept effectively. To give it a try, here’s an updated version of the project using the above code. This one is definitely not going to be posted to Autodesk Labs: one way or another I intend to optimise this implementation, whether using Bitmap.LockBits()/UnlockBits() with lower-level memory access code or some simple file caching to make sure the copping only happens once per entry. I’m hoping that the first option will work out well, as it saves us having to clean up temporary files and is (hopefully) effective even the first time run - but we’ll see that in the next post.

At least the results are good from a visual perspective:

Updated Clipboard Manager – now with preview!

As mentioned yesterday, I went ahead and integrated previewing into the Clipboard Manager Plugin of the Month. I won’t include the code directly in the post – it’s fundamentally similar in nature to that posted yesterday and is, in any case, included in the project. There were a few additional tricks needed, such as modifying the SplitterDistance property of a SplitContainer to make sure the aspect ratio of the image gets maintained, but nothing particularly earth-shattering.

Here’s the updated project – I’ll be looking into the “save between session” feature (which I suspect is going to morph into a “save to DWG file” feature, as that feels like the simplest and safest to implement) before posting a new version on Autodesk Labs.

Here’s this version in action:

I’m pleased with how the preview adjusts in size according to the image contained by the selected item. I’d be happy to hear from people who’ve given it a try and formed an opinion, one way or another. :-)

Previewing the contents of the clipboard in an AutoCAD palette using .NET

I’ve been meaning to attack this one since we first published the Clipboard Manager as a Plugin of the Month: working out how to display a preview image of the clipboard contents inside the Clipboard Manager palette. And then I happened to receive a request by email, yesterday, suggesting a couple of enhancements to the tool. A nice reminder. :-)

1. Have the clipboard include image previews, similar to that of the wblock command (instead of needing to immediately rename the item when fast copying multiple items).
2. Have the clipboard store items in memory for use in between autocad sessions (this would be useful on projects that are not completed in one day/session, or really useful when/if autocad encounters a fatal error).

To start with I thought that both of these requests would have a common solution (at their core, at least): understanding how AutoCAD places its data on the clipboard would hopefully allow us to load it into a Database and then create a thumbnail from it. And we’d also be able to save off a copy of the data for future reuse.

After asking some colleagues for their opinions (and many thanks, Davis, Lee, Markus, Murali and Jack for the input! :-) it turns out the format AutoCAD uses to write to the clipboard is defined in an ObjectARX SDK header, clipdata.h. I think I once knew this, but once again I’m a victim of my own over-efficient garbage collection :-). Here’s the relevant structure, edited to fit the width of the blog:

typedef struct tagClipboardInfo {

  ACHAR        szTempFile[260];   // block temp file name

  ACHAR        szSourceFile[260]; // file name of drawing from which

                                  // selection was made

  ACHAR        szSignature[4];    // szClipSignature

  int          nFlags;            // kbDragGeometry: dragging

                                  // geometry from AutoCAD?

  AcGePoint3d  dptInsert;         // original world coordinate of

                                  // insertion point

  RECT         rectGDI;           // GDI coord bounding rectangle of

                                  // sset

  void*        mpView;            // Used to verify that this object

                                  // was created in this view (HWND*)

  DWORD        m_dwThreadId;      // AutoCAD thread that created this

                                  // DataObject

  int          nLen;              // Length of next segment of data,

                                  // if any, starting with chData

  int          nType;             // Type of data, if any

                                  // (eExpandedClipDataTypes)

  ACHAR        chData[1];         // Start of data, if any.

} ClipboardInfo;

A number of the people I asked pointed out that AutoCAD actually WBLOCKs out the selected objects into a complete, standalone drawing file, which is referenced from this structure. The problem I suspect I’m going to have, at some point, is to map this structure to .NET, although as I know the temporary file is going to be in the first 260 characters, I could probably get away with just pulling out those characters and ignoring the rest. Although reusing them in a later session may then actually involve calling INSERT rather than placing them back into the clipboard and calling PASTECLIP, as in any case it feels as though there are some fields that might be tricky to recreate (thread ID has me nervous, for instance). But anyway – that’s for another day.

Another of the pieces of input I received had me thinking this was probably over-engineering the solution to the first request. We actually store a bunch of different formats to the clipboard – including a bitmap of the selected contents – which means we probably don’t need to care about the AutoCAD-specific format to address that request.

Rather than extending the existing VB.NET code to accomplish this, I decided to start with a simple C# app showing a palette that only displays the contents of the clipboard via an embedded PictureBox. I chose to go back to C# as I thought, at the time, I’d be mapping the above C++ structure – which would be easier – but anyway. Now that I have some working C# code I’ll be taking a look at extending the existing Clipboard Manager plugin, in due course.

Here’s the C# test code I put together. I placed everything in a single file – the UI is created by the code, rather than being in the Visual Studio designer, to keep it all simple. Oh, and I’m sorry for the lack of comments – if you’re interested in the implementation details but they’re not obvious, please leave a comment on this post.

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

using System.Runtime.InteropServices;

using System.Windows.Forms;

using System.Drawing;

using System;

 

namespace ClipboardViewing

{

  public enum Msgs

  {

    WM_DRAWCLIPBOARD = 0x0308,

    WM_CHANGECBCHAIN = 0x030D

  }

 

  public class ClipboardView : UserControl

  {

    [DllImport("user32.dll")]

    public static extern IntPtr SetClipboardViewer(

      IntPtr hWndNewViewer

    );

 

    [DllImport("user32.dll", CharSet = CharSet.Auto)]

    public static extern IntPtr SendMessage(

      IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam

    );

 

    IntPtr _nxtVwr;

    PictureBox _img;

    PaletteSet _ps;

 

    public ClipboardView(PaletteSet ps)

    {

      _img = new PictureBox();

      _img.Anchor =

        (AnchorStyles)(AnchorStyles.Top |

                      AnchorStyles.Bottom |

                      AnchorStyles.Left |

                      AnchorStyles.Right);

      _img.Location = new Point(0, 0);

      _img.Size = this.Size;

      _img.SizeMode = PictureBoxSizeMode.StretchImage;

      Controls.Add(_img);

 

      _nxtVwr = SetClipboardViewer(this.Handle);

      _ps = ps;

    }

 

    private void ExtractImage()

    {

      IDataObject iData;

      try

      {

        iData = Clipboard.GetDataObject();

      }

      catch (System.Exception ex)

      {

        MessageBox.Show(ex.ToString());

        return;

      }

 

      if (iData.GetDataPresent("Bitmap"))

      {

        object o = iData.GetData("Bitmap");

        Bitmap b = o as Bitmap;

        if (b != null)

        {

          _img.Image = b;

          if (_ps != null)

          {

            _ps.Size =

              new Size(b.Size.Width / 3, b.Size.Height / 3);

          }

        }

      }

    }

 

    protected override void WndProc(ref Message m)

    {

      switch ((Msgs)m.Msg)

      {

        case Msgs.WM_DRAWCLIPBOARD:

          ExtractImage();

          SendMessage(_nxtVwr, m.Msg, m.WParam, m.LParam);

          break;

        case Msgs.WM_CHANGECBCHAIN:

          if (m.WParam == _nxtVwr)

            _nxtVwr = m.LParam;

          else

            SendMessage(_nxtVwr, m.Msg, m.WParam, m.LParam);

          break;

        default:

          base.WndProc(ref m);

          break;

      }

    }

  }

 

  public class Commands

  {

    PaletteSet _ps = null;

    ClipboardView _cv = null;

 

    [CommandMethod("CBS")]

    public void ShowClipboard()

    {

      if (_ps == null)

      {

        _ps = new PaletteSet(

          "CBS",

          new System.Guid("DB716FC9-2BD8-49ca-B3DF-6F2523C9B8E5")

        );

 

        if (_cv == null)

          _cv = new ClipboardView(_ps);

 

        _ps.Text = "Clipboard";

        _ps.DockEnabled =

          DockSides.Left | DockSides.Right | DockSides.None;

        _ps.Size = new System.Drawing.Size(300, 500);

        _ps.Add("ClipboardView", _cv);

      }

      _ps.Visible = true;

    }

  }

}

When we run the CBS command, it displays a palette which updates when the clipboard is modified to show its contents. The palette resizes to be a third of the size of the bitmap, so the aspect ratio is maintained. You may recognise the drawing used from the last post.

So that happily ended up being much easier than expected. Now I’ll be taking a look at how best to integrate this into the Clipboard Manager. And in due course how best to handle the persistence and reuse of the data between sessions.

Changing the relative draw-order of AutoCAD objects based on their layer

Terry Dotson has – once again – generously offered an application to be an ADN Plugin of the Month. This little tool, called DrawOrderByLayer, allows you to modify the draw-order of objects in an AutoCAD drawing according to the layer they’re on. I don’t expect this to go live for another month or so (I still have plans for November’s plugin), but I did want to post it in order to give people the chance to provide feedback.

Here’s basically how it works…

You have layers containing geometry – in this case I’ve created circular solid hatches on layers named by their respective colours:

Loading the DLL and launching the DOBYLAYS command shows a simple dialog:

Once you’ve ticked/checked the layers you care about and have moved them into an appropriate relative order, clicking OK selects the objects on each layer and uses the DrawOrderTable to bring them to the top. In our case we have asked for Red, Yellow, Green and Blue to be brought to the the top (Red being the topmost of them):

I’ve made a few cosmetic changes to Terry’s code, but it’s mostly his. There may well be further changes prior to the eventually posting – I’m wondering if it’s worth streamlining the DrawOrderTable calls, for instance – but I (and, I’m sure, Terry, also) would appreciate any feedback people would like to provide, in the meantime.

Here’s the main VB.NET file:

Imports Autodesk.AutoCAD.ApplicationServices

Imports Autodesk.AutoCAD.Runtime

Imports DrawOrderByLayer.DemandLoading

 

Public Class Commands

 

  Implements IExtensionApplication

 

  ' AutoCAD fires the Initialize Sub when the assembly is loaded,

  ' so we check to see if the command is registered by looking for

  ' the existance of the Registry keys.  If not found, we attempt

  ' to add them so the command will automatically load in future

  ' sessions.  This means it only needs to be NETLOADed once.

 

  Public Sub Initialize() Implements IExtensionApplication.Initialize

    RegistryUpdate.RegisterForDemandLoading()

  End Sub

 

  Public Sub Terminate() Implements IExtensionApplication.Terminate

    ' Only fires when AutoCAD is shutting down

  End Sub

 

  <CommandMethod("ADNPLUGINS", "REMOVEDO", CommandFlags.Modal)> _

  Public Shared Sub RemoveDrawOrderByLayer()

    RegistryUpdate.UnregisterForDemandLoading()

  End Sub

 

  ' Establish our command name to use to start the tool.  It

  ' dimensions an instance of the form and displays it with

  ' AutoCAD's ShowModalDialog.  Don't use Windows Form.Show!

 

  <CommandMethod("ADNPLUGINS", "DOBYLAY", CommandFlags.Modal)> _

  Public Shared Sub OrderByLayer()

    Using dlg As New OrderDialog()

      Application.ShowModalDialog(dlg)

    End Using

  End Sub

 

End Class

Here’s the dialog implementation file:

Imports Autodesk.AutoCAD.ApplicationServices

Imports Autodesk.AutoCAD.DatabaseServices

Imports Autodesk.AutoCAD.EditorInput

Imports Autodesk.AutoCAD.Runtime

 

Public Class OrderDialog

 

  'Related System Variables

  '  DRAWORDERCTL: Controls the display order of overlapping objects.

  '    Improves editing speed in large drawings

  '  SORTENTS: Controls object sorting in support of draw order for

  '    several operations.

 

  Private Sub MainForm_Load( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles MyBase.Load

 

    ' Populate layer list with layers (in order created)

 

    Dim db As Database = _

      Application.DocumentManager.MdiActiveDocument.Database

 

    Using tr As Transaction = _

      db.TransactionManager.StartTransaction

      Dim lt As LayerTable = _

        tr.GetObject(db.LayerTableId, OpenMode.ForRead)

      For Each id As ObjectId In lt

        Dim ltr As LayerTableRecord = _

          tr.GetObject(id, OpenMode.ForRead)

        If ltr.IsDependent = False Then

          LayLst.Items.Add(ltr.Name)

        End If

      Next

      tr.Commit() ' Cheaper to commit than abort

    End Using

 

  End Sub

 

  Private Sub Accept_Click( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles Accept.Click

 

    If LayLst.CheckedItems.Count > 0 Then

 

      ' Build list of layers from those checked, then reverse it

 

      Dim revLst As New List(Of String)

      For Each TxtStr As String In LayLst.CheckedItems

        revLst.Add(TxtStr)

      Next

      revLst.Reverse()

 

      ' Get modelspace objects on each layer and pass to

      ' DrawOrderTable.MoveToTop()

 

      Dim doc As Document = _

        Application.DocumentManager.MdiActiveDocument

      Dim db As Database = doc.Database

      Dim ed As Editor = doc.Editor

 

      Using tr As Transaction = _

        db.TransactionManager.StartTransaction

        Dim bt As BlockTable = _

          tr.GetObject(db.BlockTableId, OpenMode.ForWrite)

        Dim btr As BlockTableRecord = _

          tr.GetObject( _

            bt(BlockTableRecord.ModelSpace), OpenMode.ForWrite)

        Dim dot As DrawOrderTable = _

          tr.GetObject(btr.DrawOrderTableId, OpenMode.ForWrite)

        Using pm As New ProgressMeter

          pm.Start("Processing: ")

          pm.SetLimit(LayLst.CheckedItems.Count)

          For Each lay As String In revLst

            Dim psr As PromptSelectionResult

            Dim tvs(0) As TypedValue

            tvs(0) = New TypedValue(DxfCode.LayerName, lay)

            Dim sf As New SelectionFilter(tvs)

            psr = ed.SelectAll(sf)

            If psr.Value IsNot Nothing Then

              dot.MoveToTop( _

                New ObjectIdCollection(psr.Value.GetObjectIds))

            End If

            pm.MeterProgress()

            System.Windows.Forms.Application.DoEvents()

          Next

          pm.Stop()

        End Using

        tr.Commit()

      End Using

      ed.Regen()

    End If

    Me.Close()

  End Sub

 

  Private Sub Cancel_Click( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles Cancel.Click

 

    Me.Close()

  End Sub

 

  Private Sub LayInv_Click( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles LayInv.Click

 

    For AI As Integer = 0 To LayLst.Items.Count - 1

      LayLst.SetItemChecked(AI, Not LayLst.GetItemChecked(AI))

    Next

  End Sub

 

  Private Sub LaySrt_Click( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles LaySrt.Click

 

    LayLst.Sorted = True

    LayLst.Sorted = False

  End Sub

 

  Private Sub MovUpp_Click( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles MovUpp.Click

 

    If LayLst.SelectedIndex > 0 Then

      Dim OldChk As Boolean = _

        LayLst.GetItemChecked(LayLst.SelectedIndex - 1)

      LayLst.Items.Insert( _

        LayLst.SelectedIndex + 1, _

        LayLst.Items(LayLst.SelectedIndex - 1))

      LayLst.Items.RemoveAt( _

        LayLst.SelectedIndex - 1)

      LayLst.SetItemChecked( _

        LayLst.SelectedIndex + 1, OldChk)

    End If

  End Sub

 

  Private Sub MovDnn_Click( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles MovDnn.Click

 

    If LayLst.SelectedIndex < LayLst.Items.Count - 1 Then

      Dim OldChk As Boolean = _

        LayLst.GetItemChecked(LayLst.SelectedIndex + 1)

      LayLst.Items.Insert( _

        LayLst.SelectedIndex, LayLst.Items(LayLst.SelectedIndex + 1))

      LayLst.Items.RemoveAt( _

        LayLst.SelectedIndex + 1)

      LayLst.SetItemChecked( _

        LayLst.SelectedIndex - 1, OldChk)

    End If

  End Sub

 

  Private Sub SelAll_Click( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles SelAll.Click

 

    For I As Int16 = 0 To LayLst.Items.Count - 1

      LayLst.SetItemChecked(I, True)

    Next

  End Sub

 

  Private Sub SelNon_Click( _

    ByVal sender As System.Object, ByVal e As System.EventArgs) _

    Handles SelNon.Click

 

    For I As Int16 = 0 To LayLst.Items.Count - 1

      LayLst.SetItemChecked(I, False)

    Next

  End Sub

 

End Class

And here’s the project. Thanks for providing this sample, Terry!

A 2nd Photo Scene Editor/Photofly Competition

As with the previous contest, the winner stands to win a tricked out iPad plus a signed (by Carl Bass, Autodesk’s CEO) copy of 3ds Max or 3ds Max Design. See Scott’s blog for details. The deadline for this competition is Guy Fawkes Night, November 5th.

Apparently the iPad is one of a kind, but as this is the second such competition, I have my doubts. ;-)

Oh, and yes, only inhabitants of USA and Canada are eligible to win these prizes, quite sadly, but that shouldn’t stop people from entering for the fun and prestige.

SortOnVersion in F#

I had a very nice surprise in my inbox, this morning. Thorsten Meinecke, from GTB in Berlin, decided to convert the VB.NET code contained in the last post into an F# script and to share it with this blog’s readership. Thanks, Thorsten! :-)

One thing about it being an F# script (typically stored in a .fsx file) is that it can be loaded and executed directly from the “F# Interactive” (FSI) component in Visual Studio without the need to build it into a project creating an executable. What’s also very nice is that the XAML defining the WPF dialog is embedded directly into the script, making it a simple matter to copy & paste the application into Visual Studio.

Here’s the F# code:

#I @"C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0"

#r "PresentationCore.dll"

#r "PresentationFramework.dll"

#r "WindowsBase.dll"

#r "WindowsFormsIntegration.dll"

 

open System.IO

open System.Windows.Forms

 

open System.Windows

open System.Windows.Controls

open System.Windows.Markup

open System.Windows.Media

 

let xaml =

  "<Window

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

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

    Title='Sort On Drawing Version' Height='327' Width='511'

      WindowStartupLocation='CenterScreen'>

    <Grid Height='Auto'>

    <Grid.ColumnDefinitions>

      <ColumnDefinition Width='270*' />

      <ColumnDefinition Width='270*' />

    </Grid.ColumnDefinitions>

    <Label Grid.ColumnSpan='2' Height='25' HorizontalAlignment='Left'

      Name='Label1' VerticalAlignment='Top'

      Width='77'>Root folder:</Label>

    <TextBox Grid.ColumnSpan='2' Height='26' Margin='73,-1,166,0'

      Name='FolderBox' VerticalAlignment='Top' />

    <Button Height='29' Margin='5,0,0,33' Name='CopyButton'

      VerticalAlignment='Bottom' IsEnabled='False'>Copy</Button>

    <Button Grid.ColumnSpan='2' Height='28' Margin='0,0,85,0'

      Name='BrowseButton' VerticalAlignment='Top'  Width='75'

      HorizontalAlignment='Right'>Browse...</Button>

    <ListView Grid.ColumnSpan='2' Margin='5,30,6,68'

      Name='FileList'/>

    <Button Height='28' HorizontalAlignment='Right' Margin='0,0,6,0'

      Name='ListButton' VerticalAlignment='Top' Width='73'

      IsEnabled='False' Grid.Column='1'>List</Button>

    <ProgressBar Grid.ColumnSpan='2' Height='28' Margin='5,0,6,2'

      Name='SortProgress' VerticalAlignment='Bottom' />

    <Button Grid.Column='1' Height='29' Margin='0,0,6,33'

      Name='MoveButton' VerticalAlignment='Bottom'

      IsEnabled='False'>Move</Button>

    </Grid>

  </Window>"

 

let (?) (this : Control) (prop: string) : 'T =

  this.FindName prop :?> 'T

let (+=) e f = Observable.add f e

 

let window = XamlReader.Parse xaml :?> Window

let label1: Label = window?Label1

let folderBox: TextBox = window?FolderBox

let copyButton: Button = window?CopyButton

let browseButton: Button = window?BrowseButton

let fileList: ListView = window?FileList

let listButton: Button = window?ListButton

let sortProgress: ProgressBar = window?SortProgress

let moveButton: Button = window?MoveButton

 

let getVersion fn =

 

  let (|StartsWith|_|) arg (s: string) =

    if s.StartsWith arg then Some() else None

 

  let data = Array.create 6 0uy

  use fs = File.OpenRead fn

  try

    if fs.Read(data, 0, 6) = 6 then

      match (new System.Text.ASCIIEncoding()).GetString data with

      | StartsWith "MC0.0" -> "R1.0"

      | StartsWith "AC1.2" -> "R1.2"

      | StartsWith "AC1.40" -> "R1.4"

      | StartsWith "AC1.50" -> "R2.05"

      | StartsWith "AC2.10" -> "R2.10"

      | StartsWith "AC2.21" -> "R2.21"

      | StartsWith "AC2.22" -> "R2.22"

      | StartsWith "AC1001" -> "R2.22"

      | StartsWith "AC1002" -> "R2.5"

      | StartsWith "AC1003" -> "R2.6"

      | StartsWith "AC1004" -> "R9"

      | StartsWith "AC1006" -> "R10"

      | StartsWith "AC1009" -> "R11"

      | StartsWith "AC1012" -> "R13"

      | StartsWith "AC1014" -> "R14"

      | StartsWith "AC1015" -> "2000"

      | StartsWith "AC1018" -> "2004"

      | StartsWith "AC1021" -> "2007"

      | StartsWith "AC1024" -> "2010"

      | _ -> "Unknown"

    else ""

  finally

    fs.Close()

 

let messageBox (s: string) =

  MessageBox.Show(s, "Sort On Drawing Version" ) |> ignore

 

let sortFiles move =

  let numSorted = ref 0

  let numSkipped = ref 0

  try

    if fileList.Items.Count = 0 then

      "Nothing to sort!" |> messageBox

    else

      sortProgress.Minimum <- 0.

      sortProgress.Maximum <- fileList.Items.Count - 1 |> float

      sortProgress.Value <- 0.

 

      for fn in Seq.cast fileList.Items do

        let ver = getVersion fn

        if not(System.String.IsNullOrEmpty ver) then

          let loc = Path.Combine(folderBox.Text, ver)

          if not(Directory.Exists loc) then

            Directory.CreateDirectory loc |> ignore

 

          let dest = Path.Combine(loc, Path.GetFileName fn)

          if not(File.Exists dest) then

            if move then

              File.Move(fn, dest)

            else

              File.Copy(fn, dest)

 

            incr numSorted

          else

            incr numSkipped

 

        sortProgress.Value <- sortProgress.Value + 1.

 

      System.String.Format(

        "{0} file{1} {2}, {3} (already existing) file{4} skipped.",

        !numSorted,

        (if !numSorted = 1 then "" else "s"),

        (if move then "moved" else "copied"),

        !numSkipped,

        (if !numSkipped = 1 then "" else "s" ) )

      |> messageBox

 

      sortProgress.Value <- 0.

      fileList.ItemsSource <- null

 

  with ex ->

    "A problem was found while sorting files: " + ex.Message

    |> messageBox

 

browseButton.Click +=

  fun _ ->

    let fbd =

      new FolderBrowserDialog(

        Description =

          "Select the root folder for the DWG version sort:" )

    if Directory.Exists folderBox.Text then

      fbd.SelectedPath <- folderBox.Text

    let dr = fbd.ShowDialog()

    if dr = DialogResult.OK then

      folderBox.Text <- fbd.SelectedPath

 

folderBox.TextChanged +=

  fun e ->

    let tb = e.Source :?> TextBox

    listButton.IsEnabled <- Directory.Exists tb.Text

 

listButton.Click +=

  fun _ ->

    try

      fileList.ItemsSource <-

        Directory.GetFiles(

          folderBox.Text, "*.dwg", SearchOption.AllDirectories )

    with _ ->

      "A problem was found accessing sub-folders in this " +

      "location: will simply get the drawings in the root " +

      "folder."

      |> messageBox

 

      fileList.ItemsSource <-

        Directory.GetFiles(folderBox.Text, "*.dwg")

 

  copyButton.IsEnabled <- true

  moveButton.IsEnabled <- true

 

moveButton.Click += fun _ -> sortFiles true

 

copyButton.Click += fun _ -> sortFiles false

 

#if COMPILED

[<System.STAThread>]

[<EntryPoint>]

let main _ = (new Application()).Run window

#else

(new Application()).Run window

#endif

The simple way to run this code, for those unfamiliar with using F# in Visual Studio, is to paste it into a file (usually a .fsx file), select the contents and use Alt-Enter to load it into FSI. That should cause the dialog shown in the previous post to display, and to work in an identical manner.

Thanks again for sharing this code, Thorsten!

SortOnVersion & ScriptPro

A friend in our Product Support team in Neuchâtel asked me to help develop a little application to sort drawing files on disk. He has some old Clipper scripts that he used during a previous life as a CAD Manager to sort drawing files into different folders based on their version (held in the first six bytes of the DWG file, as mentioned in this previous post and this post of Shaan’s). We decided I’d implement it in VB.NET, to make it easier for him to understand and extend.

The application is simple enough, but could make a mess of your file system: we started with just a “Copy" function but decided to extend it to cover “Move”. These functions place files in sub-folders of the selected root folder named after the version numbers of the drawings encountered:

DWGs folder

  |_ R11

  |_ R14

  |_ 2000

  |_ 2004

  |_ 2007

  |_ 2010

The “List” process parses sub-folders until it encounters an exception, at which point it defaults to listing only the drawings in the root folder. The DWGs from the various folders all then get either copied or moved into one of the version folders under the root.

Because of the potential for harm to folder hierarchies brought by introducing “Move”, I’ve decided to leave the code in source form only (and here it is). Which means someone needs to build it to make use of it, and assuming they can do that then they can presumably take responsibility for whatever the code does to their (or their users’) file system(s). ;-)

Here’s the main VB.NET file:

Imports System.Windows.Forms

Imports System.IO

Imports System.Text

 

Class SortOnVersionWindow

 

  Private Sub BrowseButton_Click( _

    ByVal sender As System.Object, _

    ByVal e As System.Windows.RoutedEventArgs) _

    Handles BrowseButton.Click

 

    Dim fbd As FolderBrowserDialog = New FolderBrowserDialog()

    fbd.Description = _

      "Select the root folder for the DWG version sort:"

    If Directory.Exists(FolderBox.Text) Then

      fbd.SelectedPath = FolderBox.Text

    End If

    Dim dr As DialogResult = fbd.ShowDialog()

    If dr = Forms.DialogResult.OK Then

      FolderBox.Text = fbd.SelectedPath

    End If

 

  End Sub

 

  Private Sub FolderBox_TextChanged( _

    ByVal sender As System.Object, _

    ByVal e As System.Windows.Controls.TextChangedEventArgs) _

    Handles FolderBox.TextChanged

 

    Dim tb As System.Windows.Controls.TextBox = _

      DirectCast(sender, System.Windows.Controls.TextBox)

    ListButton.IsEnabled = Directory.Exists(tb.Text)

 

  End Sub

 

  Private Sub ListButton_Click( _

    ByVal sender As System.Object, _

    ByVal e As System.Windows.RoutedEventArgs) _

    Handles ListButton.Click

 

    Try

 

      FileList.ItemsSource = _

        Directory.GetFiles( _

          FolderBox.Text, "*.dwg", SearchOption.AllDirectories)

 

    Catch ex As Exception

 

      MessageBox.Show( _

        "A problem was found accessing sub-folders in this " + _

        "location: will simply get the drawings in the root " + _

        "folder.", _

        "Sort On Drawing Version")

 

      FileList.ItemsSource = _

        Directory.GetFiles(FolderBox.Text, "*.dwg")

 

    End Try

 

    CopyButton.IsEnabled = True

    MoveButton.IsEnabled = True

 

  End Sub

 

  Private Sub MoveButton_Click( _

    ByVal sender As System.Object, _

    ByVal e As System.Windows.RoutedEventArgs) _

    Handles MoveButton.Click

 

    SortFiles(True)

 

  End Sub

 

  Private Sub CopyButton_Click( _

    ByVal sender As System.Object, _

    ByVal e As System.Windows.RoutedEventArgs) _

    Handles CopyButton.Click

 

    SortFiles(False)

 

  End Sub

  Private Sub SortFiles(ByVal move As Boolean)

 

    Dim numSorted As Integer = 0

    Dim numSkipped As Integer = 0

 

    Try

 

      If FileList.Items.Count = 0 Then

        MessageBox.Show( _

          "Nothing to sort!", _

          "Sort On Drawing Version")

        Return

      End If

      SortProgress.Minimum = 0

      SortProgress.Maximum = FileList.Items.Count - 1

      SortProgress.Value = 0

 

      For Each fn In FileList.Items

        Dim ver As String = GetVersion(fn)

        If Not String.IsNullOrEmpty(ver) Then

 

          Dim loc As String = FolderBox.Text + "\" + ver

          If Not Directory.Exists(loc) Then

            Directory.CreateDirectory(loc)

          End If

 

          Dim dest As String = loc + "\" + Path.GetFileName(fn)

          If Not File.Exists(dest) Then

 

            If move Then

              File.Move(fn, dest)

            Else

              File.Copy(fn, dest)

            End If

            numSorted += 1

          Else

            numSkipped += 1

          End If

 

          SortProgress.Value += 1

 

        End If

      Next

      MessageBox.Show( _

        String.Format( _

          "{0} file{1} {2}, {3} (already existing) file{4} skipped.", _

          numSorted, IIf(numSorted = 1, "", "s"), _

          IIf(move, "moved", "copied"), numSkipped, _

          IIf(numSkipped = 1, "", "s")), _

        "Sort On Drawing Version")

      SortProgress.Value = 0

 

      FileList.ItemsSource = Nothing

 

    Catch ex As Exception

      MessageBox.Show( _

        "A problem was found while sorting files: " + _

        ex.Message, _

        "Sort On Drawing Version")

    End Try

 

  End Sub

  Private Function GetVersion(ByVal fn As String) As String

 

    Dim data(5) As Byte

    Dim res As Integer

    Dim s As String = String.Empty

 

    Dim fs As FileStream = File.OpenRead(fn)

    Using (fs)

      res = fs.Read(data, 0, 6)

      If res = 6 Then

        Dim enc As ASCIIEncoding = New ASCIIEncoding()

        s = enc.GetString(data)

        Dim sh As String = s.Substring(0, 5)

 

        If sh = "MC0.0" Then

          Return "R1.0"

        ElseIf sh = "AC1.2" Then

          Return "R1.2"

        ElseIf s = "AC1.40" Then

          Return "R1.4"

        ElseIf s = "AC1.50" Then

          Return "R2.05"

        ElseIf s = "AC2.10" Then

          Return "R2.10"

        ElseIf s = "AC2.21" Then

          Return "R2.21"

        ElseIf s = "AC2.22" Then

          Return "R2.22"

        ElseIf s = "AC1001" Then

          Return "R2.22"

        ElseIf s = "AC1002" Then

          Return "R2.5"

        ElseIf s = "AC1003" Then

          Return "R2.6"

        ElseIf s = "AC1004" Then

          Return "R9"

        ElseIf s = "AC1006" Then

          Return "R10"

        ElseIf s = "AC1009" Then

          Return "R11"

        ElseIf s = "AC1012" Then

          Return "R13"

        ElseIf s = "AC1014" Then

          Return "R14"

        ElseIf s = "AC1015" Then

          Return "2000"

        ElseIf s = "AC1018" Then

          Return "2004"

        ElseIf s = "AC1021" Then

          Return "2007"

        ElseIf s = "AC1024" Then

          Return "2010"

        Else

          Return "Unknown"

        End If

      End If

        fs.Close()

    End Using

    Return s

 

  End Function

 

End Class

Here’s the main dialog, implemented using WPF, to give you an idea of how it works:

This tool may end up being a Plugin of the Month, at some point, but we’ll see. I worry about the damage that can be done by “Move” (unless we maintain some kind of undo stack or display prominent health warnings).

On the subject of our Plugins of the Month… Viru Aithal, who manages our DevTech team in India, is beavering away on a replacement for ScriptPro (whether we use the ScriptPro name or simply call it “Batch Processor” remains to be seen). He’s reimplemented – and in many ways extended – the popular ScriptPro tool using .NET, which also means it will work well on 64-bit systems (a limitation of the current VB6-implemented ScriptPro). If anyone is interested in Beta-testing this tool prior to its release, please drop me an email.

Some miscellaneous BrowsePhotosynth changes

I just thought I’d report back on a few changes made to the BrowsePhotosynth Plugin of the Month during the course of this week. The updated version has just been announced on Scott Sheppard’s blog and I thought I’d share some of the specific implementation details.

The first one (in the 1.0.1 update) was a really interesting problem and I owe a big thanks both to Alberto Venturini for reporting it and to Marat Mirgaleev, from our DevTech team in Moscow, for helping test on a comparable OS. The problem was that on all the systems upon which Alberto had tested, the various points in a Photosynth point cloud would end up on a single axis, essentially at varying distances along a line. We narrowed it down to being locale-related, and then (which I was sleeping on Monday night) the penny dropped and I realised it had to be due to the widespread use of comma as the decimal separator in non-English locales.

The application takes a number of files stored on the Photosynth servers and downloads/processes them, combining the resultant points into a single text file which then gets processed in a LAS file, which they gets indexed as a PCG and attached into AutoCAD. Phew. Here’s that in graphical form (click to enlarge):

The issue was between the F# processor and the txt2las tool: we were clearly writing decimals with comma as the decimal separator to the comma-delimited points.txt file (while txt2las expects period-/full stop-delimited decimals in a comma-delimited file, irrespective of the current locale).

The fix was actually straightforward and applies as well to VB.NET and C# as it does to F#. Here’s an example of an incorrect call:

x.ToString()

and here’s what we needed to do, instead, to make sure decimals use a period/full-stop as the decimal point, irrespective of the current locale settings:

x.ToString(CultureInfo.InvariantCulture)

We also needed to add the System.Globalization namespace, but that’s about it. Oh, and as we are in F# – which is type-inferred – we had to pin down the values being passed into the function to be of type float32, as the generic object-level ToString() doesn’t have a version taking an IFormatProvider (which CultureInfo.InvariantCulture happens to be).

The next two changes were in the 1.0.2 update that has just been posted: the F# processor’s IsComplete property previously checked the number of files that had been processed. There was an additional callback – AllCompleted – which took care of adding the number of points from each file into a total. So if the loop checked for IsComplete broke and the code went on to check the number of points downloaded – before the AllCompleted event fired – then we would incorrectly report that 0 points had been downloaded and finish the command right there. The fix was to add a boolean flag in the code to be exposed via IsComplete which only gets set to true at the end of AllCompleted.

The second of the 1.0.2 changes was simply to bring down the primary point cloud and none of the additional ones. This is the original implementation I had created, but ended up extending it to pull down multiple point clouds for each Photosynth. The trouble is, the point clouds are kept separate for a good reason: they are not spatially connected (well they actually might be, but that’s a different story and not for today’s post :-) and so have different coordinate systems. I was blindly downloading them and plonking them down into the same coordinate space, which – even if we had more points – led to messier results.

Other Photosynth exporters do provide more information on the various sizes of the point clouds available for each synth, but I’ve opted for simplicity and so just take the first one (which is usually the largest). The code could easily be extended to provide more choice for the user in this area, should anyone feel the need to do so.

Which actually means the results of importing the Menzi Muck synth from the last post (and also it’s new big brother) look better than I’d previously reported.

Hopefully that’s it for the code changes to this tool, for now, but please do let us know if you experience any further issues with it.