Rotate, Scale, Project, and Mirror a Line Entity Example (C#)

//-------------------------------------------------------------------
// Preconditions:
// 1. Create a C# Windows console project.
// 2. Copy and paste this project into the C# IDE.
// 3. Add a reference to:
//    install_dir\APISDK\tlb\DraftSight.Interop.dsAutomation.
// 4. Add references to System and System.Windows.Forms.
// 5. Start DraftSight.
// 6. Run the macro.
//
// Postconditions:  
// 1. A Line is drawn, rotated, scaled, projected, and
//    mirrored.
// 2. The transformation parameters are printed before each
//    transformation.
// 3. The Line parameters are printed before and after
//    each transformation.
//-------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
using DraftSight.Interop.dsAutomation;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Diagnostics;

namespace MathFunctionality
{
    class Program
    {
        private static DraftSight.Interop.dsAutomation.Application dsApp;

        static void Main(string[] args)
        {
            //Connect to DraftSight application
            dsApp = ConnectToDraftSight();
            if (null == dsApp)
            {
                return;
            }

            dsApp.AbortRunningCommand(); // abort any command currently running in DraftSight to avoid nested commands

            //Get active document
            Document dsDoc = dsApp.GetActiveDocument();
            if (null == dsDoc)
            {
                MessageBox.Show("There are no open documents in DraftSight.");
                return;
            }

            //Get math utility
            MathUtility dsMathUtility = dsApp.GetMathUtility();

            //Create different transformations
            Dictionary<string, MathTransform> transformations = CreateDifferentTransformations(dsMathUtility);

            //Draw a Line
            Line dsLine = DrawLine(dsDoc);

            TransformLine(dsLine, transformations);
        }

        private static Dictionary<string, MathTransform> CreateDifferentTransformations(MathUtility dsMathUtility)
        {
            Dictionary<string, MathTransform> transformations = new Dictionary<string, MathTransform>();

            //Create translation transformation
            MathVector dsTranslationVector = dsMathUtility.CreateVector(2, 3, 0);
            MathTransform dsTranslationTransformation = dsMathUtility.CreateTransformTranslation(dsTranslationVector);

            transformations.Add("translation", dsTranslationTransformation);

            //Create scaling transformation
            MathPoint dsCenterPoint = dsMathUtility.CreatePoint(0, 0, 0);
            double scaleFactor = 1.2;
            MathTransform dsScalingTransformation = dsMathUtility.CreateTransformScaling(dsCenterPoint, scaleFactor);

            transformations.Add("scaling", dsScalingTransformation);

            //Create rotation transformation
            MathVector dsRotationAxis = dsMathUtility.CreateVector(0, 0, 1);
            double rotationAngle = Math.PI / 4; //45 degrees in radians
            MathTransform dsRotationTransformation = dsMathUtility.CreateTransformRotation(dsCenterPoint, dsRotationAxis,
                                                                                           rotationAngle);

            transformations.Add("rotation", dsRotationTransformation);

            //Create mirror transformation about point
            MathPoint dsMirrorPoint = dsMathUtility.CreatePoint(0, 0, 0);
            MathTransform dsMirrorAboutPointTransformation = dsMathUtility.CreateTransformMirroringAboutPoint(dsMirrorPoint);

            transformations.Add("mirror about point", dsMirrorAboutPointTransformation);

            //Create mirror transformation about Line
            MathLine dsMirrorLine = dsMathUtility.CreateLine(0, 0, 0, 0, 20, 0, dsMathLineType_e.dsMathLineType_Bounded);
            MathTransform dsMirrorAboutLineTransformation = dsMathUtility.CreateTransformMirroringAboutLine(dsMirrorLine);

            transformations.Add("mirror about Line", dsMirrorAboutLineTransformation);

            //Create mirror transformation about plane
            MathPlane dsMirrorPlane = dsMathUtility.CreateZXPlane();
            MathTransform dsMirrorAboutPlaneTransformation = dsMathUtility.CreateTransformMirroringAboutPlane(dsMirrorPlane);

            transformations.Add("mirror about plane", dsMirrorAboutPlaneTransformation);

            //Create projection transformation
            MathPlane dsProjectionPlane = dsMathUtility.CreateYZPlane();
            MathVector dsProjectionDirection = dsMathUtility.CreateVector(1, 0, 0);
            MathTransform dsProjectionTransformation = dsMathUtility.CreateTransformProjection(dsProjectionPlane, dsProjectionDirection);

            transformations.Add("projection", dsProjectionTransformation);

            return transformations;
        }

        private static void TransformLine(Line dsLine, Dictionary<string, MathTransform> transformations)
        {
            //Get MathLine property of Line entity
            MathLine dsMathLine = dsLine.MathLine;

            //Print mathematical line parameters
            PrintMathLineParameters(dsMathLine);

            //Transform Line using the created transformations
            foreach (KeyValuePair<string, MathTransform> transformationItem in transformations)
            {
                //Print transformation parameters
                PrintMathTransformation(transformationItem.Key, transformationItem.Value);

                //Transform mathematical line
                dsMathLine.TransformBy(transformationItem.Value);

                //Update Line
                dsLine.MathLine = dsMathLine;

                MessageBox.Show("The " + transformationItem.Key + " transformation has been applied to a Line.");

                //Zoom by window
                double[] lowerLeftCorner = { -10, -10, 0 };
                double[] upperRightCorner = { 10, 10, 0 };
                dsApp.Zoom(dsZoomRange_e.dsZoomRange_Window, lowerLeftCorner, upperRightCorner);

                //Print result mathematical line parameters
                PrintMathLineParameters(dsMathLine);
            }
        }

        private static Line DrawLine(Document dsDoc)
        {
            //Get model space
            Model dsModel = dsDoc.GetModel();

            //Get sketch manager
            SketchManager dsSketchMgr = dsModel.GetSketchManager();

            //Draw a Line
            double[] startPoint = { 1, 1, 0 };
            double[] endPoint = { 5, 1, 0 };

            return dsSketchMgr.InsertLine(startPoint[0], startPoint[1], startPoint[2],
                                          endPoint[0], endPoint[1], endPoint[2]);
        }

        private static void PrintMathTransformation(string transformationName, MathTransform dsMathTransformation)
        {
            Debug.Print(Environment.NewLine + "The " + transformationName + " transformation:");

            int countOfRows = 4;
            int countOfColumns = 4;

            for (int i = 0; i < countOfRows; ++i)
            {
                string rowInformation = "(";

                for (int j = 0; j < countOfColumns; ++j)
                {
                    rowInformation += dsMathTransformation.GetElementAt(i, j);

                    if (j != countOfColumns - 1)
                    {
                        rowInformation += "  ,  ";
                    }
                }

                rowInformation += ");";

                Debug.Print(rowInformation);
            }
        }

        private static void PrintMathLineParameters(MathLine dsMathLine)
        {
            Debug.Print(Environment.NewLine + "Mathematical line parameters");

            Debug.Print(string.Format("Type = {0};", dsMathLine.GetType().ToString()));

            //Get start point
            MathPoint dsPoint = dsMathLine.StartPoint;

            double x, y, z;
            dsPoint.GetPosition(out x, out y, out z);

            Debug.Print(string.Format("StartPoint ({0}, {1}, {2});", x, y, z));

            //Get end point
            dsPoint = dsMathLine.EndPoint;

            dsPoint.GetPosition(out x, out y, out z);

            Debug.Print(string.Format("EndPoint ({0}, {1}, {2});", x, y, z));

            //Get direction
            MathVector dsVector;
            dsMathLine.GetDirection(out dsVector);

            dsVector.GetCoordinates(out x, out y, out z);

            Debug.Print(string.Format("Direction ({0}, {1}, {2});", x, y, z));

            Debug.Print(string.Format("Length = {0};", dsMathLine.GetLength().ToString()));
        }

        private static DraftSight.Interop.dsAutomation.Application ConnectToDraftSight()
        {
            DraftSight.Interop.dsAutomation.Application dsApp = null;

            try
            {
                //Connect to DraftSight
                dsApp = (DraftSight.Interop.dsAutomation.Application)Marshal.GetActiveObject("DraftSight.Application");
            }
            catch (Exception ex)
            {
                MessageBox.Show("Failed to connect to DraftSight. Cause: " + ex.Message);
                dsApp = null;
            }

            return dsApp;
        }
    }
}