At Developer Day, EDA Software Engineer Madison Miner will be presenting the advantages of web-based automation programs as well as discussing best practices when automating Solid Edge on the web. Fellow presenters at Developer Day will include Greg Chasteen (Technical Account Manager, Siemens PLM Software) and Jason Newell (founder of the Solid Edge programming resource site JasonNewell.net).  Anyone interested in Solid Edge programming should definitely attend Developer Day.  Topics listed on Siemens’s website include:

• An overview of the Solid Edge API
• Automating Solid Edge
• Using Microsoft .NET
• Creating Addins and Apps.
• An update on the latest development tools for Solid Edge ST5
• Round Table discussion with the actual Solid Edge developers.
• And More!!

Developing Web Applications for Solid Edge

Want to get a sneak peek at the Web-based program we’ll be bring to SEU?  This demo shows how a manufacturer of custom products (electrical enclosures in this case) could allow their customers or sales staff to design a unique product on the Web, submit it online, and then receive Solid Edge models or drawings to spec via email, all generated in a few minutes by an automated Solid Edge design program developed by EDA.

As a Siemens Solution Partner  for Solid Edge and a Solid Edge Application Developer, EDA staff will be available to meet with Solid Edge users one-on-one at the conference and discuss developing custom Solid Edge applications.  Improve your company’s Solid Edge productivity by automating the design of your products.  To make an appointment to meet during the conference, please contact EDA or call 360-398-1319 (US).

Custom models created online using EDA automated programs

There are a couple ways to find and select components or features in the SolidWorks Feature Tree.  Both of these are built into SolidWorks and can be very helpful when the Feature Tree becomes too large or complex to search through manually.  However, these tools also have their limitations– which is why I got EDA’s software engineers to write me a SolidWorks addin to provide the user with a more powerful search and select tool.

In my case, I had to find and select 50 parts from an assembly of 1500+ parts, some of them 8 levels deep so I could change their appearance to match various backgrounds.  This process had to be repeated for each of the 7 backgrounds that I had to work with.   Yikes!

1500+ parts, 8 levels deep!

The obvious and most basic tool for navigating the SolidWorks Feature Manager is the Go To command.  Just right click  in the Feature Manager and select “Go To…” and type in your search critera.  When you click  “Find Next”, the next feature or component that fulfills your search criteria in the tree is highlighted.  This is fine if you are just looking for one component or feature, but it doesn’t help you search for ALL components that satisfy the search criteria, only the next one.  It will also find mates and reference geometry and other non-components, which I wasn’t interested in.

Go To finds only the next item in tree

Another built-in tool is the Feature Manger Filter.  By typing in the search criteria in the filter box, SolidWorks will show only those components/features that satisfy your search criteria.  This is a quick way to cut through a lot of parts or features and find only those items you want.  However, this tool also has its limitations.  It does not show components if they are hidden or suppressed, and it does not select the filtered components, so you still have to manually select the components in the graphics window or the Feature Tree before you can modify their appearance or perform other actions on them.

Filtering components is helpful but the command doesn't select the filtered parts...

The SelectByName addin developed by EDA is simple to use (it has its own menu with only one command, so you can’t really miss it!).  Type your search criteria into the search box, hit “OK” and the program goes through the entire feature tree, level by level, searching for and selecting every part or feature that fulfills the search criteria.  It works even on parts that may be hidden or suppressed.  In my 1500+ part assembly, it took about 5 seconds to go through every level and select all the parts I was looking for.  Now changing the appearance of all these parts at once is just a matter clicking on the Edit Appearance icon in the Heads Up Toolbar and adjusting the colors, illumination, etc.  Thanks guys!

SelectByName searches all levels and selects all parts that meet the criteria

Contact EDA if you have a custom SolidWorks programming application or add in you’d like to develop.

To give you a visual reference for my problem, here is the sample block to be inserted:

Here is the sample drawing into which the above block is to be inserted:

And this is the desired result:

We must of course keep in mind that the extents of the drawing has no relation to the extents of the current view, unless of course you have just performed a zoom extents upon the drawing. At which point they will appear to be the same.

Fortunately AutoCAD provides a means for retrieving information on the currently active viewport. A viewport as the name implies is view upon the objects of the drawing. The drawing objects themselves are defined within a three dimensional (3D) space, using X, Y, and Z coordinates. The viewport however is two dimensional (2D); it has a width and height with a center point that is directed along a particular direction with a specified twist. In the simplest case you can image peering down the Z axis at objects on the X,Y plane, not unlike looking straight down from the top of the Golden Gate Bridge.

The direction of this viewport may or may not be pointed at the objects in the drawing. Additionally the twist of the viewport may cause those same objects to appear rotated to the point of being upside down.

So regardless of how the viewport was oriented, I still want the above mentioned block to insert at the upper right of the viewport. Also as I mentioned, AutoCAD provides a means to obtain the viewport information. However this viewport information is not only specified in 2D (X,Y coordinates), but it is also defined in something called the DCS, which stands for the Display Coordinate System. The objects of the drawing are in 3D (X,Y,Z coordinates) and use something called the WCS, meaning the World Coordinate System. Most user input into AutoCAD, including through the API (AutoCAD’s programming interface), requires that points be specified in WCS; the end points of lines, the center of a circle, and in our particular case, the insertion point of a block.

So while it is not difficult to determine the 2D point of the upper right of the viewport, converting that 2D point in DCS to a 3D point in WCS requires knowing matrix algebra. Something that typically isn’t taught until second year college mathematics.

But once again, AutoCAD provides a convenient Matrix3d class to help us deal with the problem. But even with this help you still need to know what you’re doing in order to utilize it. This is where a great web site called Through the Interface provided the key to my answer. I can not say enough good things about this site. While I have not been able to solve every problem I’ve run into I could usually find enough pieces of information to allow me to find the relevant classes or keywords with which to search the enormous ObjectARX documentation.

The key to my answer was found within a post on using Kinect; amongst the listing of the source code lay the nugget I required. A short simple routine that provides a transformation matrix to allow coordinates to be converted based on a viewport, as follows:

    public static Matrix3d Wcs2Dcs(AbstractViewTableRecord vtr)
    {
        Matrix3d mat = Matrix3d.PlaneToWorld(vtr.ViewDirection);
        mat = Matrix3d.Displacement(vtr.Target - Point3d.Origin) * mat;
        mat = Matrix3d.Rotation(-vtr.ViewTwist, vtr.ViewDirection, vtr.Target) * mat;
        return mat.Inverse();
    }

But wait, the sharp-eyed among will say, that routine returns a matrix for converting WCS to DCS when in fact we need to convert in the other direction!

Fortunately both matrix algebra and AutoCAD provide a simple means for doing this, called the inverse of the matrix. While the details of the inverse are not important for us, the results are. If are interested in the details please check out the link to EuclideanSpace.com. It is very good site for those with a mathematical bent.

You will notice that the Wcs2Dcs() routine constructs a matrix by using the 2D DCS information of a ViewTableRecord (this is how AutoCAD stores a viewport). The last line of that routine returns the inverse of that matrix. In matrix algebra, the inverse of the inverse of a matrix is the same as the original matrix. Thus I can solve my problem by just using the inverse of the returned matrix as follows:

    Matrix3d dcs2wcs = Wcs2Dcs(view_table_record).Inverse();

Thus to convert a 2D DCS point to a 3D WCS point would appear as follows:

    Point2d  center_dcs = view_table_record.CenterPoint;
    Matrix3d dcs2wcs    = Wcs2Dcs(view_table_record).Inverse();
    Point3d  center_wcs = center_dcs.TransformBy(dcs2wcs);

Note the convenient .TransformBy() call provided by AutoCAD’s Point2d class that converts our DCS center point to a WCS point using the inverse of the transformation matrix returned by the Wcs2Dcs() routine.

Below you’ll find the actual C# source code for a routine called GetActiveViewportExtents()which returns the current viewport’s extents, i.e., the lower-left-most and upper-right-most points. You will also find sample code that makes use of this routine to insert a block at the upper-right most point of the current viewport. For simplicity of the block insertion an AutoLISP command is sent to AutoCAD to do all the work. Yet another nugget gleamed from the Through the Interface web site.

Please note that while this code will always insert the block at the upper-right of the viewport, it is possible that this block may not be visible, or be only partially visible, due to the twist angle of that viewport.

Project References: AcDbMgd.dll, AcMgd.dll

Sample Code: Visual Studio 2010, C#, .NET Framework 3.5, AutoCAD 2012 Plug-in, .NET ObjectARX

Source File: AcadHelper.cs

// Copyright (C) 2011 by EDA Inc.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

// Project references to both AcMgd.dll & AcDbMgd.dll of ObjectARX are required.
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.EditorInput;

namespace EDAInc.AcadAPI
{
    internal static class AcadHelper
    {
        // Generates the transformation matrix to go from WCS to DCS
        // units in a view/viewport.
        //      WCS - World Coordinate System
        //      DCS - Display Coordinate System
        // Copied from:
        //      http://through-the-interface.typepad.com/through_the_interface/2011/11/
        //                         navigating-an-autocad-model-using-kinect-part-1.html
        //
        // To get a DCS to WCS transformation matrix, use the inverse of
        // the return matrix.  E.g.,
        //      Matrix3d dcs2wcs = Wcs2Dcs(vtr).Inverse();
        //
        public static Matrix3d Wcs2Dcs(AbstractViewTableRecord vtr)
        {
            Matrix3d mat = Matrix3d.PlaneToWorld(vtr.ViewDirection);
            mat = Matrix3d.Displacement(vtr.Target - Point3d.Origin) * mat;
            mat = Matrix3d.Rotation(
                    -vtr.ViewTwist, vtr.ViewDirection, vtr.Target) * mat;
            return mat.Inverse();
        }

        public static bool GetActiveViewportExtents(Document aDoc,
                                                    out Point3d aMinExtWCS,
                                                    out Point3d aMaxExtWCS)
        {
            if (aDoc == null)
                aDoc = Application.DocumentManager.MdiActiveDocument;
            Database db = aDoc.Database;
            Editor ed = aDoc.Editor;

            using (Transaction tr = db.TransactionManager.StartTransaction()) {
                try {
                    ed.UpdateTiledViewportsInDatabase();

                    // Open the active view port.
                    ViewportTableRecord vp_rec = (ViewportTableRecord)
                            tr.GetObject(ed.ActiveViewportId, OpenMode.ForRead);

                    // Find the min & max extents of the active view port in the DCS.
                    Point2d center_dcs = vp_rec.CenterPoint;
                    double half_width_dcs = vp_rec.Width / 2;
                    double half_height_dcs = vp_rec.Height / 2;
                    Point3d min_ext_dcs = new Point3d(
                            center_dcs.X - half_width_dcs,
                            center_dcs.Y - half_height_dcs,
                            0);
                    Point3d max_ext_dcs = new Point3d(
                            center_dcs.X + half_width_dcs,
                            center_dcs.Y + half_height_dcs,
                            0);

                    // Convert the min & max extents of the view port to WCS.
                    Matrix3d dcs2wcs = AcadHelper.Wcs2Dcs(vp_rec).Inverse();
                    aMinExtWCS = min_ext_dcs.TransformBy(dcs2wcs);
                    aMaxExtWCS = max_ext_dcs.TransformBy(dcs2wcs);

                    tr.Commit();
                    return true;
                }
                catch (Autodesk.AutoCAD.Runtime.Exception ex) {
                    tr.Abort();
					ed.WriteMessage("\n" + ex.Message + "\n");
                    aMinExtWCS = Point3d.Origin;
                    aMaxExtWCS = Point3d.Origin;
                    return false;
                }
            }
        }
    }
}

Source File: SampleUsage.cs

// Copyright (C) 2011 by EDA Inc.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.EditorInput;

namespace VendorName.AppName
{
    internal class SampleUsage
    {
        private Document mDoc;   // AutoCAD's drawing window
        private Editor mEd;      // AutoCAD's input/output command-line editor

        // Constructor
        public SampleUsage()
        {
	        // Get the currently active AutoCAD drawing at the time
            // that this class is created.
            mDoc = Application.DocumentManager.MdiActiveDocument;
            mEd = mDoc.Editor;
        }

        public void Test(string aBlockFilename,
                         int aAttributeValue1,
                         string aAttributeValue2)
        {
            // Use the upper-right extents of the current/active view
            // as the default location for the block insertion location.
            Point3d min_exts;
            Point3d max_exts;   // upper-right extent
            AcadHelper.GetActiveViewportExtents(mDoc, out min_exts, out max_exts);

            // Send an AutoLISP command to insert the block.
			// Example syntax:
            //     (command "_insert" "blockname.dwg" '(x y z) xScale yScale angle "1001" "5' - 6\"")
            string lisp_cmd =
                "(command \"_insert\" \"" + aBlockFilename + "\" " +
                    "'(" + max_exts.X.ToString() + " " +
                           max_exts.Y.ToString() + " " +
                           max_exts.Z.ToString() + ") " +
                    "1 1 0 " +  // X,Y scaling of 1; rotation of 0 degrees
                    "\"" + aAttributeValue1.ToString() + "\" " + // 1st attribute of the block
                    "\"" + aAttributeValue2 + "\"" +             // 2nd attribute
                    ")\n";

            // Note: AutoCAD will NOT execute this command string until AFTER this
            //       routine has returned control to AutoCAD.
            mDoc.SendStringToExecute(lisp_cmd, true, false, true);
        }
    }
}

http://solidsmack.com/3d-cad-technology/evoluent-vertical-mouse-design/

I was so bummed because my trackball mouse just died recently and I had to order a new one. I wished I had seen this post first, because it really does look like a more comfortable position for your hand and more ergonomically correct. I use my trackball all day, and while it is much better for my wrist & hand than a regular mouse, I often still have issues with my mouse hand/arm.

I guess the vertical mouse has been around since the mid 90′s but this was the first time I’d ever seen one. But did I really want to throw away my new trackball & shell out $90 for a new one?

Not as ergonomic as it could be.

Then the light bulb went on.

See picture below to see how to turn your regular trackball mouse into a vertical mouse. It totally works! I like my “new” vertical mouse so much better!

DIY strikes again!

mSE.ActiveDocument.SaveAs(@"C:\Path\File.SAT");

I Googled for a solution and found this post indicating that saving a SAT file through the User Interface used to be a problem with Solid Edge in ST3, however it was fixed in ST3 Maintenance Pack 1. Apparently only saving a .SAT file through the UI was corrected, saving a .SAT file through the API still presents a challenge.

I tried many, many work arounds to solve the issue, but I will not bore you with the details of each failed attempt. What finally worked was starting Solid Edge by using Process.Start instead of starting Solid Edge with Activator.CreateInstance.

When starting Solid Edge with Activator.CreateInstance the “-Automation” parameter is set, typically you want this to be set when using the API, however Solid Edge will not save a .SAT file when this parameter is set. Starting Solid Edge with Process.Start the  “-Automation” parameter is NOT set, it is basically like double clicking the Solid Edge icon.

With the -Automation parameter not set Solid Edge will save .SAT files as expected, even through the API.

Of course this presents a few other problems. Without the -Automation parameter Solid Edge will display prompts, this can lock up the API, so make sure to set DisplayAlerts = false. Also, if you are using a trial version of Solid Edge the Solid Edge Licence warning will be displayed when you start Solid Edge with Process.Start, so you will have to dismiss this dialog using the Windows API. Also, Solid Edge takes some time to start up, so you will have to wait for it to be started before you can connect to it.

My old startSolidEdge function looked like this:

        private bool startSolidEdge()
            {
            try
                {
                // Get the type from the Solid Edge ProgID
                WriteToLog("Starting Solid Edge");
                Type type = Type.GetTypeFromProgID("SolidEdge.Application");
                // Start Solid Edge
                mSE = (SolidEdgeFramework.Application)
                  Activator.CreateInstance(type);

                WriteToLog("Solid Edge Started");

                return true;
                }
            catch (System.Exception ex)
                {
                    WriteToLog("Failed to Start Solid Edge", EventLogEntryType.Error);
                    throw new Exception("Could not start SOLID EDGE " + ex.Message);
                }
            }

My new startSolidEdge function looks like this:

       private bool startSolidEdge(string aPathToSolidEdgeEXE)
            {
            try
                {
                    WriteToLog("Starting Solid Edge");
                    Process.Start(aPathToSolidEdgeEXE);

                    //Sleep in case the licensing splash screen appears
                    Thread.Sleep(5000);

                    //close the splash screen if it is open
                    KillWindowByTitle("Solid Edge Licensing");

		    //Give SE 90 seconds to start
                    int maxNumberOfTries = 18;
                    int numberOfTries = 0;

                    while (mSE == null && numberOfTries < maxNumberOfTries)
                        {
                        try
                            {
                            Thread.Sleep(5000);
                            mSE = (SolidEdgeFramework.Application)
                                  Marshal.GetActiveObject("SolidEdge.Application");
                            }
                        catch
                            {
                            numberOfTries+= 1;
                            }
                        }

                    if (mSE == null)
                        {
                        return false;
                        }

                    mSE.DisplayAlerts = false;
                    mSE.ShowStartupScreen = false;
                    mSE.Visible = true;
                    mSE.WindowState = 1;

                WriteToLog("Solid Edge Started");

                return true;
                }
            catch (System.Exception ex)
                {
                    WriteToLog("Failed to Start Solid Edge", EventLogEntryType.Error);
                    throw new Exception("Could not start SOLID EDGE " + ex.Message);
                }
            }

Hope this helps someone!

Happy New Year from the staff at EDA!