Autodesk Map3d 2010 with WCF (III)

Author: Jonio, Dennis

The snippets below are an example for a client. It did take some time to research the parameters required for a long lived(8 hour) service. It turned out to be that two(2) parameters have to be set, InactivityTimeout and ReceiveTimeout. Needless to say these should match the service’s ServiceEndpoint configuration.

In general the way the service works is that you can send it data with any one(1) of three(3) different methods. I only employ one(1) of those methods in this case. If your application has “Subscribed” you will be sent via the callback method any and all output from the service. I really do not attempt to track the “state” of anything. As the book explains, and to say the least, state tracking is probably not the best way to expend your time and energy.

From Map3d's perspective the new, improved DataBridge is really a non issue. For all intent and purpose Map3d will see things the same way. I am sure that as time moves on the complexity of "if" and "case" statements will grow.
I plan on following this article with the complete DataBridge Version II.
Source code snippets for a client(C#):

+ expand sourceview plainprint?

1.      public static IByteSrvcWCallback SrvcHost;  
2.      public static ByteSrvcCallbackImpl callbackImpl;  
3.      public static DuplexChannelFactory<ibytesrvcwcallback> dcf;  
4.      public static Guid MyServicedName;  
5.      public static string MyPrefixForMap3dDQ = "MDADCLSSFYIO";  
6.      public static string AddressOfReliableSessionService = "net.tcp://localhost:9080/DataService";  
7.   
8.   
9.      public MainForm()  
10.      {  
11.          InitializeComponent();  
12.          NetTcpBinding ntb = new NetTcpBinding(SecurityMode.None, true);  
13.          ntb.ReliableSession.Enabled = true;  
14.          ntb.ReliableSession.Ordered = true;  
15.          ntb.ReliableSession.InactivityTimeout = new TimeSpan(0, 8, 0, 0);  
16.          ntb.ReceiveTimeout = new TimeSpan(0, 8, 0, 0);  
17.          callbackImpl = new ByteSrvcCallbackImpl();  
18.          InstanceContext ic = new InstanceContext(callbackImpl);  
19.          dcf = new DuplexChannelFactory<ibytesrvcwcallback>(  
20.                       ic,  
21.                       ntb,  
22.                       new EndpointAddress(AddressOfReliableSessionService));  
23.          SrvcHost = dcf.CreateChannel();  
24.          callbackImpl.OnGotControlPacket +=   
25. new ByteSrvcCallbackImpl.GotControlPacket(WCF_RcvdSrvcControlPacket);  
26.          MyServicedName = Guid.Empty;  
27.      }  
28.   
29.         void WCF_RcvdSrvcControlPacket(byte[] ba)  
30.         {  
31.             byte[] x = callbackImpl.ControlPacket;  
32.             //  
33.             //Here is the callback  
34.             //Do something useful with the data that the Service has sent to you  
35.            //  
36.         }  
37.   
38.         public int WCF_SendToMap3dDataBridge(byte[] ba)  
39.         {  
40.             return SrvcHost.DQPipedIn(MyPrefixForMap3dDQ, ba);  
41.         }  
42.   
43.         private void btnSUBSCRIBE_Click(object sender, EventArgs e)  
44.         {  
45.             try  
46.             {  
47.                 if (MyServicedName == Guid.Empty)  
48.                     MyServicedName = SrvcHost.Subscribe();  
49.             }  
50.             catch (EndpointNotFoundException _epnfX)  
51.             {  
52.                 AppendMessage("EndPoint ERROR: " + _epnfX.Message);  
53.             }  
54.             catch (System.Exception _eX)  
55.             {  
56.                 AppendMessage("ERROR: " + _eX.Message);  
57.             }  
58.         }  
59.   
60.         private void btnUNSUBSCRIBE_Click(object sender, EventArgs e)  
61.         {  
62.             try  
63.             {  
64.                 if (MyServicedName != Guid.Empty)  
65.                     SrvcHost.UnSubscribe(MyServicedName);  
66.                 MyServicedName = Guid.Empty;  
67.             }  
68.             catch (EndpointNotFoundException _epnfX)  
69.             {  
70.                 AppendMessage("EndPoint ERROR: " + _epnfX.Message);  
71.             }  
72.             catch (System.Exception _eX)  
73.             {  
74.                 AppendMessage("ERROR: " + _eX.Message);  
75.             }  
76.         }  
77. </ibytesrvcwcallback></ibytesrvcwcallback>  

     public static IByteSrvcWCallback SrvcHost;
     public static ByteSrvcCallbackImpl callbackImpl;
     public static DuplexChannelFactory dcf;
     public static Guid MyServicedName;
     public static string MyPrefixForMap3dDQ = "MDADCLSSFYIO";
     public static string AddressOfReliableSessionService = "net.tcp://localhost:9080/DataService";


     public MainForm()
     {
         InitializeComponent();
         NetTcpBinding ntb = new NetTcpBinding(SecurityMode.None, true);
         ntb.ReliableSession.Enabled = true;
         ntb.ReliableSession.Ordered = true;
         ntb.ReliableSession.InactivityTimeout = new TimeSpan(0, 8, 0, 0);
         ntb.ReceiveTimeout = new TimeSpan(0, 8, 0, 0);
         callbackImpl = new ByteSrvcCallbackImpl();
         InstanceContext ic = new InstanceContext(callbackImpl);
         dcf = new DuplexChannelFactory(
                      ic,
                      ntb,
                      new EndpointAddress(AddressOfReliableSessionService));
         SrvcHost = dcf.CreateChannel();
         callbackImpl.OnGotControlPacket += 
new ByteSrvcCallbackImpl.GotControlPacket(WCF_RcvdSrvcControlPacket);
         MyServicedName = Guid.Empty;
     }

        void WCF_RcvdSrvcControlPacket(byte[] ba)
        {
            byte[] x = callbackImpl.ControlPacket;
            //
            //Here is the callback
            //Do something useful with the data that the Service has sent to you
           //
        }

        public int WCF_SendToMap3dDataBridge(byte[] ba)
        {
            return SrvcHost.DQPipedIn(MyPrefixForMap3dDQ, ba);
        }

        private void btnSUBSCRIBE_Click(object sender, EventArgs e)
        {
            try
            {
                if (MyServicedName == Guid.Empty)
                    MyServicedName = SrvcHost.Subscribe();
            }
            catch (EndpointNotFoundException _epnfX)
            {
                AppendMessage("EndPoint ERROR: " + _epnfX.Message);
            }
            catch (System.Exception _eX)
            {
                AppendMessage("ERROR: " + _eX.Message);
            }
        }

        private void btnUNSUBSCRIBE_Click(object sender, EventArgs e)
        {
            try
            {
                if (MyServicedName != Guid.Empty)
                    SrvcHost.UnSubscribe(MyServicedName);
                MyServicedName = Guid.Empty;
            }
            catch (EndpointNotFoundException _epnfX)
            {
                AppendMessage("EndPoint ERROR: " + _epnfX.Message);
            }
            catch (System.Exception _eX)
            {
                AppendMessage("ERROR: " + _eX.Message);
            }
        }

Autodesk Map3d 2010 with WCF (II)

Author: Jonio, Dennis

I make absolutely no attempt here to explain why I have done the things the way I have done them in relationship to the grand scheme of WCF. There is just too much to explain and you really should get the book and improve on what I have done. I stopped a long time ago in trying to force Map3d to do multi-threading. As it turns out this is not debilitating at all, just use a Form.
The following are my concrete classes for the WCF interfaces found in the previous article. Making no value judgments, you do have to be impressed with how much Microsoft has done in producing the “behind the scenes” transport functionality. Since I wanted “required, reliable sessions with binary transport” I have coded towards the NetTcpBinding and the NetNamedPipeBinding.
As you can see there are two(2) methods for getting data to the service and the service has one(1) method to send data back to the client. During research I happened upon this multiple client subscription concept with a simple Guid identifier. I desperately wanted some kind of "session identifier" that was all ready in place, generic and robust. If you do the reading you will discover WCF has the concept of SessionId but in my mind's eye it is too crippled to be of any use for my purpose. This subscription paradigm struck me as a good, simple and straightforward idea.
The service itself.
Source code (C#):

+ expand sourceview plainprint?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.ServiceModel;  
6.   
7. namespace DplXByteSrvcs  
8. {  
9.     [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,  
10.                      ConcurrencyMode = ConcurrencyMode.Reentrant)]  
11.     public class ByteSrvcWCallbackImpl : IByteSrvcWCallback  
12.     {  
13.         public delegate void DataIsReady(byte[] hotData);  
14.         public DataIsReady DataReady = null;  
15.   
16.         public delegate void DQDataIsReady(string destinationQ, byte[] hotData);  
17.         public DQDataIsReady DQDataReady = null;  
18.   
19.         public delegate void GotControlPacket(byte[] hotPacket);  
20.         public GotControlPacket OnGotControlPacket = null;  
21.   
22.         public readonly Dictionary<guid, ibytesrvccallback=""> SrvcClients =   
23.                                                 new Dictionary<guid, ibytesrvccallback="">();  
24.   
25.         public void ControlPacket(byte[] ba)  
26.         {  
27.             int rtnval = 0;  
28.             if (ba != null)  
29.                 rtnval = ba.Length;  
30.             if (OnGotControlPacket != null)  
31.                 OnGotControlPacket(ba);  
32.   
33.             IByteSrvcCallback callback = OperationContext.Current.GetCallbackChannel<ibytesrvccallback>();  
34.             if (!SrvcClients.ContainsValue(callback))  
35.             {  
36.                 Guid clientId = Guid.NewGuid();  
37.                 if (callback != null)  
38.                 {  
39.                     lock (SrvcClients)  
40.                     {  
41.                         SrvcClients.Add(clientId, callback);  
42.                     }  
43.                 }  
44.             }  
45.         }  
46.         public int PipedIn(byte[] data)  
47.         {  
48.             int rtnval = 0;  
49.             if (data != null)  
50.                 rtnval = data.Length;  
51.   
52.             if (DataReady != null)  
53.                 DataReady(data);  
54.   
55.             return rtnval;  
56.         }  
57.         public int DQPipedIn(string destinationQ, byte[] data)  
58.         {  
59.             int rtnval = 0;  
60.             if (data != null)  
61.                 rtnval = data.Length;  
62.   
63.             if (DQDataReady != null)  
64.                 DQDataReady(destinationQ, data);  
65.   
66.             return rtnval;  
67.         }  
68.         Guid IByteSrvcWCallback.Subscribe()  
69.         {  
70.             IByteSrvcCallback callback =  
71.                 OperationContext.Current.GetCallbackChannel<ibytesrvccallback>();  
72.             Guid clientId = Guid.NewGuid();  
73.             if (callback != null)  
74.             {  
75.                 lock (SrvcClients)  
76.                 {  
77.                     SrvcClients.Add(clientId, callback);  
78.                 }  
79.             }  
80.             return clientId;  
81.         }  
82.         void IByteSrvcWCallback.UnSubscribe(Guid clientGID)  
83.         {  
84.             lock (SrvcClients)  
85.             {  
86.                 if (SrvcClients.ContainsKey(clientGID))  
87.                 {  
88.                     SrvcClients.Remove(clientGID);  
89.                 }  
90.             }  
91.         }  
92.         void IByteSrvcWCallback.NoOpButKeepAlive() { }  
93.   
94.     }//EOC  
95. }//EONS  
96. </ibytesrvccallback></ibytesrvccallback></guid,></guid,>  

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace DplXByteSrvcs
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
                     ConcurrencyMode = ConcurrencyMode.Reentrant)]
    public class ByteSrvcWCallbackImpl : IByteSrvcWCallback
    {
        public delegate void DataIsReady(byte[] hotData);
        public DataIsReady DataReady = null;

        public delegate void DQDataIsReady(string destinationQ, byte[] hotData);
        public DQDataIsReady DQDataReady = null;

        public delegate void GotControlPacket(byte[] hotPacket);
        public GotControlPacket OnGotControlPacket = null;

        public readonly Dictionary SrvcClients = 
                                                new Dictionary();

        public void ControlPacket(byte[] ba)
        {
            int rtnval = 0;
            if (ba != null)
                rtnval = ba.Length;
            if (OnGotControlPacket != null)
                OnGotControlPacket(ba);

            IByteSrvcCallback callback = OperationContext.Current.GetCallbackChannel();
            if (!SrvcClients.ContainsValue(callback))
            {
                Guid clientId = Guid.NewGuid();
                if (callback != null)
                {
                    lock (SrvcClients)
                    {
                        SrvcClients.Add(clientId, callback);
                    }
                }
            }
        }
        public int PipedIn(byte[] data)
        {
            int rtnval = 0;
            if (data != null)
                rtnval = data.Length;

            if (DataReady != null)
                DataReady(data);

            return rtnval;
        }
        public int DQPipedIn(string destinationQ, byte[] data)
        {
            int rtnval = 0;
            if (data != null)
                rtnval = data.Length;

            if (DQDataReady != null)
                DQDataReady(destinationQ, data);

            return rtnval;
        }
        Guid IByteSrvcWCallback.Subscribe()
        {
            IByteSrvcCallback callback =
                OperationContext.Current.GetCallbackChannel();
            Guid clientId = Guid.NewGuid();
            if (callback != null)
            {
                lock (SrvcClients)
                {
                    SrvcClients.Add(clientId, callback);
                }
            }
            return clientId;
        }
        void IByteSrvcWCallback.UnSubscribe(Guid clientGID)
        {
            lock (SrvcClients)
            {
                if (SrvcClients.ContainsKey(clientGID))
                {
                    SrvcClients.Remove(clientGID);
                }
            }
        }
        void IByteSrvcWCallback.NoOpButKeepAlive() { }

    }//EOC
}//EONS

You will discover as I did that the communications piece is really all about the client. Nothing much happens without them.
Now for the Client the callback class.
Source code (C#):

+ expand sourceview plainprint?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace DplXByteSrvcs  
7. {  
8.     public class ByteSrvcCallbackImpl : IByteSrvcCallback  
9.     {  
10.         public delegate void GotControlPacket(byte[] hotPacket);  
11.         public GotControlPacket OnGotControlPacket = null;  
12.   
13.         private byte[] m_ba;  
14.         public byte[] ControlPacket  
15.         {  
16.             get { return m_ba; }  
17.         }  
18.         public void SentControlPacket(byte[] ba)  
19.         {  
20.             m_ba = ba;  
21.             if (OnGotControlPacket != null)  
22.                 OnGotControlPacket(ba);  
23.         }  
24.     }  
25. }  

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DplXByteSrvcs
{
    public class ByteSrvcCallbackImpl : IByteSrvcCallback
    {
        public delegate void GotControlPacket(byte[] hotPacket);
        public GotControlPacket OnGotControlPacket = null;

        private byte[] m_ba;
        public byte[] ControlPacket
        {
            get { return m_ba; }
        }
        public void SentControlPacket(byte[] ba)
        {
            m_ba = ba;
            if (OnGotControlPacket != null)
                OnGotControlPacket(ba);
        }
    }
}

Autodesk Map3d 2010 and WCF (I)

Author: Jonio, Dennis

Well, I finally finished my first Windows Communication Foundation(WCF) project. Ever since .NET Framework 3.0 came out I had been curious but until now the chance to delve into it just never appeared. The prompt was to get some flexibility into the IPC chores between my custom Autodesk application modules(netloads) and my .NET applications.
First off, I certainly join the chorus that promotes getting Juval Lowy’s work Programming WCF Services (in my case 2nd Edition). There is a multitude of nuance and subtlety that would be left to chance without reading this work. In addition I do not have a clue where else a person would go to get his kind of depth of understanding. A real "must have" if you are serious about WCF.
As I spent more time with WCF I certainly learned of some of its strengths and weakness’. I really did waiver a lot concerning implementing the callback interface versus just using the simplest of operation contracts with each executable acting as a hosting service and likewise a client. This would have made this new interface very similar to my previous NamedPipe interface in that both sides act as host and client. In the end I choose the WCF DuplexChannel/callback paradigm because I figured out the rather straightforward way to keep the session(s) alive over an extended period of time.
If you are at all familiar with my previous work with IPC you know that I pass serialized datasets around as opposed to passing more granular objects. I do not stray from this paradigm. It has served me well and I cannot think of any reason to change.

The following are my interface definitions for the service and callback. I will leave the class implementation for a follow up.
Source code (C#):

+ expand sourceview plainprint?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.ServiceModel;  
6.   
7. namespace DplXByteSrvcs  
8. {  
9.     [ServiceContract(Namespace = "WCF.MDAD.SERVICES",  
10.                     CallbackContract = typeof(IByteSrvcCallback),  
11.                     SessionMode = SessionMode.Required)]  
12.     public interface IByteSrvcWCallback  
13.     {  
14.         [OperationContract(IsOneWay = true)]  
15.         void ControlPacket(byte[] baIn);  
16.   
17.         [OperationContract]  
18.         [TransactionFlow(TransactionFlowOption.Allowed)]  
19.         int PipedIn(byte[] data);  
20.   
21.         [OperationContract]  
22.         [TransactionFlow(TransactionFlowOption.Allowed)]  
23.         int DQPipedIn(string destinationQ, byte[] data);  
24.   
25.         [OperationContract]  
26.         Guid Subscribe();  
27.         [OperationContract(IsOneWay = true)]  
28.         void UnSubscribe(Guid clientId);  
29.         [OperationContract(IsOneWay = true)]  
30.         void NoOpButKeepAlive();  
31.   
32.     }  
33.     public interface IByteSrvcCallback  
34.     {  
35.         [OperationContract(IsOneWay = true)]  
36.         void SentControlPacket(byte[] baOut);  
37.     }  
38. }  

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace DplXByteSrvcs
{
    [ServiceContract(Namespace = "WCF.MDAD.SERVICES",
                    CallbackContract = typeof(IByteSrvcCallback),
                    SessionMode = SessionMode.Required)]
    public interface IByteSrvcWCallback
    {
        [OperationContract(IsOneWay = true)]
        void ControlPacket(byte[] baIn);

        [OperationContract]
        [TransactionFlow(TransactionFlowOption.Allowed)]
        int PipedIn(byte[] data);

        [OperationContract]
        [TransactionFlow(TransactionFlowOption.Allowed)]
        int DQPipedIn(string destinationQ, byte[] data);

        [OperationContract]
        Guid Subscribe();
        [OperationContract(IsOneWay = true)]
        void UnSubscribe(Guid clientId);
        [OperationContract(IsOneWay = true)]
        void NoOpButKeepAlive();

    }
    public interface IByteSrvcCallback
    {
        [OperationContract(IsOneWay = true)]
        void SentControlPacket(byte[] baOut);
    }
}

(VII) New SDO_GEOMETRY <-> Autodesk Map3d 2010

Author: Jonio, Dennis

The next and last items on the list ...

Given one or more Autodesk/Map3d objects decompose it(them) into “Drawable(s)”.

Given a “DrawAble” compose a Autodesk/Map3d object.

This is the class that interacts with Autodesk Map3d. (I have removed a few things that are not importtant to the discussion here.)
First, as time has gone on I have grown weary of parseing out Autodesk/Map3d objects and manipulating them. I gravitated toward AppendLoopFromBoundary() and BalanceTree() for MPolygon construction. Just a lot less code on my part. If it isn't a Point type I force just about everything to a Polyline at one time or the other. If you really need true 3D objects you shouldn't be reading this anyway.
Just some things of note:

I never output an Oracle Circle

I never output an Oracle Rectangle

I never output an Oracle SDO_POINT
I will read them and write them as Autdesk objects but after this they loose their identity as such.

This is the last post on this topic. I have decided NOT to post the working source and project. If you are interested in the final work leave a comment with your email address.

Since I produce only VALIDATED geometry I will be working on the post of my latest iteration of my IO class for doing validation against the database.
Source code (C#):

+ expand sourceview plainprint?

1. using MDADDrawAbles;  
2. using SDO = MDADDrawAbles.DrawAbleSdoGeometryUtil;  
3.   
4. using NetSdoGeometry;  
5.   
6. namespace MDADDrawAbleDwg  
7. {  
8.     public class DrawAbleDwg  
9.     {  
10.         //  
11.         // POINT  
12.         //  
13.         public static DrawAble PointDrawAbleFromPoint(Point3d p3d, int _dimensionality)  
14.         {  
15.             DrawAble dp = new DrawAble(DrawAbleType.Point, _dimensionality);  
16.             DrawAbleSubComponent dpc = new DrawAbleSubComponent();  
17.             dpc.Etype = DrawAbleSubComponentEType.Point;  
18.             int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
19.             dpc.Ords = new decimal[len];  
20.             dpc.Ords[0] = System.Convert.ToDecimal(p3d.X);  
21.             dpc.Ords[1] = System.Convert.ToDecimal(p3d.Y);  
22.             if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
23.                 dpc.Ords[2] = System.Convert.ToDecimal(p3d.Z);  
24.             dp.SubComponents.Add(dpc);  
25.             return dp;  
26.         }  
27.         public static DrawAble PointDrawAbleFromPoint(DBPoint dbp, int _dimensionality)  
28.         {  
29.             DrawAble dp = new DrawAble(DrawAbleType.Point, _dimensionality);  
30.             DrawAbleSubComponent dpc = new DrawAbleSubComponent();  
31.             dpc.Etype = DrawAbleSubComponentEType.Point;  
32.             int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
33.             dpc.Ords = new decimal[len];  
34.             dpc.Ords[0] = System.Convert.ToDecimal(dbp.Position.X);  
35.             dpc.Ords[1] = System.Convert.ToDecimal(dbp.Position.Y);  
36.             if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
37.                 dpc.Ords[2] = System.Convert.ToDecimal(dbp.Position.Z);  
38.             dp.SubComponents.Add(dpc);  
39.             return dp;  
40.         }  
41.         //  
42.         // POINT CLUSTER  
43.         //  
44.         public static DrawAble PointClusterDrawAbleFromPointList(List<point3d> p3dList, int _dimensionality)  
45.         {  
46.             DrawAble dp = new DrawAble(DrawAbleType.Point, _dimensionality);  
47.             DrawAbleSubComponent dpc = new DrawAbleSubComponent();  
48.             dpc.Etype = DrawAbleSubComponentEType.PointCluster;  
49.             int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
50.             dpc.Ords = new decimal[len * p3dList.Count];  
51.             int p3d_counter = 0;  
52.             for (int _k = 0; _k < dpc.Ords.Length; )  
53.             {  
54.                 dpc.Ords[_k] = System.Convert.ToDecimal(p3dList[p3d_counter].X);  
55.                 dpc.Ords[_k + 1] = System.Convert.ToDecimal(p3dList[p3d_counter].Y);  
56.                 if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
57.                     dpc.Ords[_k + 2] = System.Convert.ToDecimal(p3dList[p3d_counter].Z);  
58.                 _k = _k + len;  
59.                 p3d_counter = p3d_counter + 1;  
60.             }  
61.             dpc.Elem = new int[] { 0, 1, p3dList.Count };  
62.             dp.SubComponents.Add(dpc);  
63.             return dp;  
64.         }  
65.         //  
66.         // LINES  
67.         //  
68.         public static DrawAble LineCurveDrawAbleFromPolyline(Polyline pl, Polyline2d pl2d, Polyline3d pl3d, int _dimensionality)  
69.         {  
70.             DrawAble dl = new DrawAble(DrawAbleType.Line, _dimensionality);  
71.             int hasBulgesCount = 0;  
72.             Point3dCollection tmppts = null;  
73.             DoubleCollection tmpblgs = null;  
74.             Point3d[] pts = null;  
75.             double[] blgs = null;  
76.             if (pl != null)  
77.             {  
78.                 tmppts = new Point3dCollection();  
79.                 tmpblgs = new DoubleCollection();  
80.                 int i = 0;  
81.                 for (; i < pl.NumberOfVertices; i++)  
82.                 {  
83.                     switch (pl.GetSegmentType(i))  
84.                     {  
85.                         case SegmentType.Arc:  
86.                             CircularArc2d ca2d = pl.GetArcSegment2dAt(i);  
87.                             double bulge = GetBulge2d(ca2d);  
88.                             tmpblgs.Add(bulge);  
89.                             tmppts.Add(new Point3d(ca2d.StartPoint.X, ca2d.StartPoint.Y, pl.GetPoint3dAt(i).Z));  
90.                             hasBulgesCount++;  
91.                             ca2d.Dispose();  
92.                             break;  
93.                         default:  
94.                             tmpblgs.Add(0.0);  
95.                             tmppts.Add(new Point3d(pl.GetPoint3dAt(i).X, pl.GetPoint3dAt(i).Y, pl.GetPoint3dAt(i).Z));  
96.                             break;  
97.                     }  
98.                 }  
99.                 // Do NOT duplicate any point ... this appears to have different behavior for   
100.                 // the 2D and 3D polylines so we will check them all.  
101.                 if (pl.Closed && (tmppts[0].IsEqualTo(tmppts[tmppts.Count - 1]) == false))  
102.                 {  
103.                     //tmppts.Add(new Point3d(pl.GetPoint2dAt(0).X, pl.GetPoint2dAt(0).Y, 0.0));  
104.                     tmppts.Add(new Point3d(pl.GetPoint3dAt(0).X, pl.GetPoint3dAt(0).Y, pl.GetPoint3dAt(0).Z));  
105.                     tmpblgs.Add(0.0);  
106.                 }  
107.                 // Now we can dimensions our array stuctures and fill them up  
108.                 pts = new Point3d[tmppts.Count];  
109.                 blgs = new double[tmppts.Count];  
110.                 for (int z = 0; z < tmppts.Count; z++)  
111.                 {  
112.                     pts[z] = new Point3d(tmppts[z].X, tmppts[z].Y, tmppts[z].Z);  
113.                     blgs[z] = tmpblgs[z];  
114.                 }  
115.                 tmppts.Clear();  
116.                 tmppts.Dispose();  
117.                 tmpblgs.Clear();  
118.             }  
119.             //END OF POLYLINE  
120.             //START OF POLYLINE2D  
121.             if (pl2d != null)  
122.             {  
123.                 // No way of knowing how many we have so we need this to collect the points  
124.                 tmppts = new Point3dCollection();  
125.                 tmpblgs = new DoubleCollection();  
126.                 if (pl2d.PolyType == Poly2dType.SimplePoly)  
127.                 {  
128.                     Transaction t = pl2d.Database.TransactionManager.StartTransaction();  
129.                     IEnumerator iterate = pl2d.GetEnumerator();  
130.                     while (iterate.MoveNext())  
131.                     {  
132.                         ObjectId id = (ObjectId)iterate.Current;  
133.                         Vertex2d vertex = (Vertex2d)t.GetObject(id, OpenMode.ForRead);  
134.                         tmppts.Add(vertex.Position);  
135.                         tmpblgs.Add(vertex.Bulge);  
136.                         if (vertex.Bulge != 0.0)  
137.                             hasBulgesCount++;  
138.                     }  
139.                     t.Abort();  
140.                     t.Dispose();  
141.                 }  
142.                 else  
143.                 {  
144.                     DBObjectCollection collection = new DBObjectCollection();  
145.                     pl2d.Explode(collection);  
146.                     foreach (Line line in collection)  
147.                     {  
148.                         tmppts.Add(line.StartPoint);  
149.                         tmpblgs.Add(0.0);  
150.                         tmppts.Add(line.EndPoint);  
151.                         tmpblgs.Add(0.0);  
152.                     }  
153.                     collection.Dispose();  
154.                 }  
155.                 // Do NOT duplicate any point  
156.                 if (pl2d.Closed && (tmppts[0].IsEqualTo(tmppts[tmppts.Count - 1]) == false))  
157.                 {  
158.                     tmppts.Add(tmppts[0]);  
159.                     tmpblgs.Add(0.0);  
160.                 }  
161.                 // Now we can dimensions our array stuctures and fill them up  
162.                 pts = new Point3d[tmppts.Count];  
163.                 blgs = new double[tmppts.Count];  
164.                 for (int z = 0; z < tmppts.Count; z++)  
165.                 {  
166.                     pts[z] = new Point3d(tmppts[z].X, tmppts[z].Y, tmppts[z].Z);  
167.                     blgs[z] = tmpblgs[z];  
168.                 }  
169.                 tmppts.Clear();  
170.                 tmppts.Dispose();  
171.                 tmpblgs.Clear();  
172.             }  
173.             //END OF POLYLINE2D  
174.             //START OF POLYLINE3D  
175.             if (pl3d != null)  
176.             {  
177.                 tmppts = new Point3dCollection();  
178.                 tmpblgs = new DoubleCollection();  
179.                 if (pl3d.PolyType == Poly3dType.SimplePoly)  
180.                 {  
181.                     Transaction t = pl3d.Database.TransactionManager.StartTransaction();  
182.                     IEnumerator iterator = pl3d.GetEnumerator();  
183.                     while (iterator.MoveNext())  
184.                     {  
185.                         ObjectId id = (ObjectId)iterator.Current;  
186.                         PolylineVertex3d vertex3d = (PolylineVertex3d)t.GetObject(id, OpenMode.ForRead);  
187.                         tmppts.Add(vertex3d.Position);  
188.                         tmpblgs.Add(0.0);  
189.                     }  
190.                     t.Abort();  
191.                     t.Dispose();  
192.                 }  
193.                 else  
194.                 {  
195.                     DBObjectCollection collection = new DBObjectCollection();  
196.                     pl3d.Explode(collection);  
197.                     foreach (Line line in collection)  
198.                     {  
199.                         tmppts.Add(line.StartPoint);  
200.                         tmpblgs.Add(0.0);  
201.                         tmppts.Add(line.EndPoint);  
202.                         tmpblgs.Add(0.0);  
203.                     }  
204.                     collection.Dispose();  
205.                 }  
206.                 // Do NOT duplicate any point  
207.                 if (pl3d.Closed && (tmppts[0].IsEqualTo(tmppts[tmppts.Count - 1]) == false))  
208.                 {  
209.                     tmppts.Add(tmppts[0]);  
210.                     tmpblgs.Add(0.0);  
211.                 }  
212.                 // Now we can dimensions our array stuctures and fill them up  
213.                 pts = new Point3d[tmppts.Count];  
214.                 blgs = new double[tmppts.Count];  
215.                 for (int z = 0; z < tmppts.Count; z++)  
216.                 {  
217.                     pts[z] = new Point3d(tmppts[z].X, tmppts[z].Y, tmppts[z].Z);  
218.                     blgs[z] = tmpblgs[z];  
219.                 }  
220.                 tmppts.Clear();  
221.                 tmppts.Dispose();  
222.                 tmpblgs.Clear();  
223.             }  
224.             //END OF POLYLINE3D  
225.             //  
226.             // Finished getting all the ordinates and bulges for this linecurve  
227.             //  
228.             DrawAbleSubComponent dlc = new DrawAbleSubComponent();  
229.             if (hasBulgesCount == 0)  
230.             {  
231.                 dlc.Etype = DrawAbleSubComponentEType.SimpleLine;  
232.                 int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
233.                 dlc.Ords = new decimal[len * pts.Length];  
234.                 int pts_counter = 0;  
235.                 for (int _k = 0; _k < dlc.Ords.Length; )  
236.                 {  
237.                     dlc.Ords[_k] = System.Convert.ToDecimal(pts[pts_counter].X);  
238.                     dlc.Ords[_k + 1] = System.Convert.ToDecimal(pts[pts_counter].Y);  
239.                     if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
240.                         dlc.Ords[_k + 2] = System.Convert.ToDecimal(pts[pts_counter].Z);  
241.                     _k = _k + len;  
242.                     pts_counter = pts_counter + 1;  
243.                 }  
244.                 dl.SubComponents.Add(dlc);  
245.             }  
246.             else if (hasBulgesCount == pts.Length - 1)  
247.             {  
248.                 dlc.Etype = DrawAbleSubComponentEType.SimpleLineAllCurves;  
249.                 int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
250.                 dlc.Ords = new decimal[(len * pts.Length) + (hasBulgesCount * len)];  
251.                 int ords_counter = 0;  
252.                 Point3d arc_endpoint;  
253.   
254.                 for (int j = 0; j < pts.Length; j++)  
255.                 {  
256.                     double theBulge = blgs[j];  
257.                     arc_endpoint = pts[j + 1];  
258.                     CircularArc2d ca2d = new CircularArc2d(  
259.                         new Point2d(pts[j].X, pts[j].Y),  
260.                         new Point2d(arc_endpoint.X, arc_endpoint.Y), theBulge, false);  
261.   
262.                     Interval interval_of_arc = ca2d.GetInterval();  
263.                     Point2d somePointOnArc = ca2d.EvaluatePoint(interval_of_arc.Element / 2);  
264.                     //Start  
265.                     dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);  
266.                     dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);  
267.                     if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
268.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);  
269.                     //Center point on arc  
270.                     dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.X);  
271.                     dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.Y);  
272.                     if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
273.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);  
274.   
275.                     //Because of LOOK-AHEAD we now check for the end  
276.                     if (j == (pts.Length - 2))  
277.                     {  
278.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(arc_endpoint.X);  
279.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(arc_endpoint.Y);  
280.                         if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
281.                             dlc.Ords[ords_counter++] = System.Convert.ToDecimal(arc_endpoint.Z);  
282.                         j = pts.Length; //End the loop  
283.                     }  
284.                 }  
285.                 dl.SubComponents.Add(dlc);  
286.             }  
287.             else  
288.             {  
289.                 //DIM_ELEMENTS are required  
290.                 dlc.Etype = DrawAbleSubComponentEType.CompoundLine;  
291.                 int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
292.                 dlc.Ords = new decimal[(len * pts.Length) + (hasBulgesCount * len)];  
293.                 int ords_counter = 0;  
294.                 Point3d arc_endpoint;  
295.   
296.                 TriInts elmHeader = new TriInts(ords_counter, SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundLine), 0);  
297.                 List<triints> elmList = new List<triints>();  
298.                 TriInts wrkrElm = null;  
299.                 int nxtINTERP = 0;  
300.                 int lstINTERP = 0;  
301.                 for (int j = 0; j < pts.Length; j++)  
302.                 {  
303.                     if (j < pts.Length - 1)  
304.                         nxtINTERP = (blgs[j] == 0.0) ? (int)SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleLine) : (int)SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleLineAllCurves);  
305.   
306.                     if (lstINTERP != nxtINTERP)  
307.                     {  
308.                         if (wrkrElm != null)  
309.                             elmList.Add(wrkrElm);  
310.                         wrkrElm = new TriInts(ords_counter, SDO.BasicETYPE(DrawAbleSubComponentEType.SimpleLineAllCurves), nxtINTERP);  
311.                         lstINTERP = nxtINTERP;  
312.                     }  
313.   
314.                     double theBulge = blgs[j];  
315.                     if (theBulge != 0.0)  
316.                     {  
317.                         arc_endpoint = pts[j + 1];  
318.                         CircularArc2d ca2d = new CircularArc2d(  
319.                             new Point2d(pts[j].X, pts[j].Y),  
320.                             new Point2d(arc_endpoint.X, arc_endpoint.Y), theBulge, false);  
321.   
322.                         Interval interval_of_arc = ca2d.GetInterval();  
323.                         Point2d somePointOnArc = ca2d.EvaluatePoint(interval_of_arc.Element / 2);  
324.                         //Start  
325.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);  
326.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);  
327.                         if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
328.                             dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);  
329.                         //Center point on arc  
330.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.X);  
331.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.Y);  
332.                         if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
333.                             dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);  
334.                     }  
335.                     else  
336.                     {  
337.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);  
338.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);  
339.                         if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
340.                             dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);  
341.                     }  
342.   
343.                 }//for loop  
344.                 elmList.Add(wrkrElm);  
345.                 elmHeader.INTERP = elmList.Count;  
346.                 dlc.Elem = new int[(elmList.Count + 1) * 3];  
347.                 int cntr = 0;  
348.                 dlc.Elem[cntr++] = elmHeader.OFFSET;  
349.                 dlc.Elem[cntr++] = elmHeader.ETYPE;  
350.                 dlc.Elem[cntr++] = elmHeader.INTERP;  
351.                 for (int _i = 0; _i < elmList.Count; _i++)  
352.                 {  
353.                     dlc.Elem[cntr++] = elmList[_i].OFFSET;  
354.                     dlc.Elem[cntr++] = elmList[_i].ETYPE;  
355.                     dlc.Elem[cntr++] = elmList[_i].INTERP;  
356.                 }  
357.                 dl.SubComponents.Add(dlc);  
358.             }  
359.             return dl;  
360.         }  
361.         public static DrawAble LineCurveDrawAbleFromArc(Arc a, int _dimensionality)  
362.         {  
363.             DrawAble d = new DrawAble(DrawAbleType.Line, _dimensionality);  
364.             DrawAbleSubComponent dc = new DrawAbleSubComponent();  
365.             dc.Etype = DrawAbleSubComponentEType.SimpleLineAllCurves;  
366.             int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
367.             dc.Ords = new decimal[len * 3];  
368.             double length = a.GetDistAtPoint(a.EndPoint);  
369.             Point3d mid = a.GetPointAtDist(length / 2.0);  
370.             int ords_counter = 0;  
371.             //Start  
372.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.StartPoint.X);  
373.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.StartPoint.Y);  
374.             if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
375.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.StartPoint.Z);  
376.             //Mid  
377.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(mid.X);  
378.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(mid.Y);  
379.             if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
380.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(mid.Z);  
381.             //End  
382.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.EndPoint.X);  
383.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.EndPoint.Y);  
384.             if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
385.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.EndPoint.Z);  
386.             d.SubComponents.Add(dc);  
387.   
388.             return d;  
389.         }  
390.         public static DrawAble LineCurveDrawAbleFromLine(Line l, int _dimensionality)  
391.         {  
392.             DrawAble d = new DrawAble(DrawAbleType.Line, _dimensionality);  
393.             DrawAbleSubComponent dc = new DrawAbleSubComponent();  
394.             dc.Etype = DrawAbleSubComponentEType.SimpleLine;  
395.             int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
396.             dc.Ords = new decimal[len * 2];  
397.             int ords_counter = 0;  
398.             //Start  
399.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.StartPoint.X);  
400.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.StartPoint.Y);  
401.             if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
402.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.StartPoint.Z);  
403.             //End  
404.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.EndPoint.X);  
405.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.EndPoint.Y);  
406.             if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
407.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.EndPoint.Z);  
408.             d.SubComponents.Add(dc);  
409.   
410.             return d;  
411.         }  
412.         public static DrawAble LineCurveDrawAbleFromCircle(Circle circ, int _dimensionality)  
413.         {  
414.             DrawAble d = new DrawAble(DrawAbleType.Line, _dimensionality);  
415.             DrawAbleSubComponent dc = new DrawAbleSubComponent();  
416.             dc.Etype = DrawAbleSubComponentEType.SimpleLineAllCurves;  
417.             int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? 15 : 10;           
418.             dc.Ords = new decimal[len];  
419.             int ords_counter = 0;              
420.             double length = circ.Circumference;  
421.             Point3d firstarc_endpoint = circ.GetPointAtDist(length / 2.0);  
422.             Point3d firstarc_midpoint = circ.GetPointAtDist((length / 2.0) / 2.0);  
423.             Point3d secondarc_midpoint = circ.GetPointAtDist(length * .75);  
424.             //Start  
425.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.StartPoint.X);  
426.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.StartPoint.Y);  
427.             if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
428.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.StartPoint.Z);  
429.             //mid 1  
430.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_midpoint.X);  
431.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_midpoint.Y);  
432.             if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
433.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_midpoint.Z);  
434.             //End  
435.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_endpoint.X);  
436.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_endpoint.Y);  
437.             if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
438.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_endpoint.Z);  
439.             //mid 2  
440.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(secondarc_midpoint.X);  
441.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(secondarc_midpoint.Y);  
442.             if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
443.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(secondarc_midpoint.Z);  
444.             //End  
445.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.EndPoint.X);  
446.             dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.EndPoint.Y);  
447.             if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
448.                 dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.EndPoint.Z);  
449.   
450.             d.SubComponents.Add(dc);  
451.   
452.             return d;  
453.         }  
454.         //  
455.         // SURFACES  
456.         //  
457.         public static DrawAble PolygonDrawAbleFromMPolygon(MPolygon mpoly, int _dimensionality)  
458.         {  
459.             DrawAble dl = new DrawAble(DrawAbleType.Surface, _dimensionality);  
460.             Point3dCollection p3dColl = new Point3dCollection();  
461.             LoopDirection loopdirection;  
462.             int ords_counter = 0;                           // The total ordinates in the array  
463.             int hasBulgesCount = 0;  
464.             int loops = mpoly.NumMPolygonLoops;  
465.             for (int i = 0; i < loops; i++)  
466.             {  
467.                 // Gather up points and bulges for this loop  
468.                 MPolygonLoop mPolygonLoop = mpoly.GetMPolygonLoopAt(i);  
469.                 loopdirection = mpoly.GetLoopDirection(i);  
470.                 hasBulgesCount = 0;  
471.                 ords_counter = 0;  
472.                 // Remove duplicate verticies  
473.                 for (int d = 1; d < mPolygonLoop.Count - 1; d++)  
474.                 {  
475.                     if (mPolygonLoop[d].Vertex.IsEqualTo(mPolygonLoop[d + 1].Vertex))  
476.                     {  
477.                         mPolygonLoop.RemoveAt(d + 1);  
478.                     }  
479.                 }  
480.                 //  
481.                 Point3d[] pts = new Point3d[mPolygonLoop.Count];  
482.                 double[] blgs = new double[mPolygonLoop.Count];  
483.                 for (int z = 0; z < mPolygonLoop.Count; z++)  
484.                 {  
485.                     if (z == mPolygonLoop.Count - 1)  
486.                     {  
487.                         pts[z] = pts[0];  
488.                     }  
489.                     else  
490.                     {  
491.                         double X = Math.Round(mPolygonLoop[z].Vertex.X, 10, MidpointRounding.AwayFromZero);  
492.                         double Y = Math.Round(mPolygonLoop[z].Vertex.Y, 10, MidpointRounding.AwayFromZero);  
493.                         double Z = Math.Round(mpoly.Elevation, 10, MidpointRounding.AwayFromZero);  
494.                         pts[z] = new Point3d(X, Y, Z);  
495.                     }  
496.                     blgs[z] = mPolygonLoop[z].Bulge;  
497.                     if (blgs[z] != 0.0)  
498.                         hasBulgesCount = hasBulgesCount + 1;  
499.                 }  
500.                 //  
501.                 // Suspect code here ......  
502.                 //  
503.                 if (blgs[0] == blgs[mPolygonLoop.Count - 1] && blgs[0] != 0.0)  
504.                 {  
505.                     blgs[mPolygonLoop.Count - 1] = 0.0;  
506.                     hasBulgesCount--;  
507.                 }  
508.                 //  
509.                 //DO THE STUFF  
510.                 //  
511.                 DrawAbleSubComponent dlc = new DrawAbleSubComponent();  
512.                 TriInts headerElem = new TriInts(ords_counter, 0, 0);  
513.                 if (hasBulgesCount == 0)  
514.                 {  
515.                     headerElem.INTERP = SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine);  
516.                 }  
517.                 //else if (hasBulgesCount == pts.Length)  
518.                 else if (hasBulgesCount == pts.Length - 1)  
519.                 {  
520.                     headerElem.INTERP = SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves);  
521.                 }  
522.   
523.                 if (loopdirection == LoopDirection.Exterior)  
524.                 {  
525.                     if (headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine) ||  
526.                         headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves))  
527.                     {  
528.                         headerElem.ETYPE = SDO.BasicETYPE(DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine);  
529.                         if (headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine))  
530.                             dlc.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine;  
531.                         else  
532.                             dlc.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves;  
533.                     }  
534.                 }  
535.                 else  
536.                 {  
537.   
538.                     if (headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine) ||  
539.                         headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves))  
540.                     {  
541.                         headerElem.ETYPE = SDO.BasicETYPE(DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine);  
542.                         if (headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine))  
543.                             dlc.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine;  
544.                         else  
545.                             dlc.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves;  
546.                     }  
547.                 }  
548.                 // If we have not set the etype it must be a 1005 0R 2005 - compound polygon  
549.                 if (headerElem.ETYPE == 0 && hasBulgesCount > 0)  
550.                 {  
551.                     if (loopdirection == LoopDirection.Exterior)  
552.                     {  
553.                         headerElem.ETYPE = SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine);  
554.                         dlc.Etype = DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine;  
555.                     }  
556.                     else  
557.                     {  
558.                         headerElem.ETYPE = SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine);  
559.                         dlc.Etype = DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine;  
560.                     }  
561.                     headerElem.INTERP = 0; // to be set later with count  
562.                 }  
563.                 //Now we are ready to build the elem and ords  
564.                 int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;  
565.                 dlc.Ords = new decimal[(len * pts.Length) + (hasBulgesCount * len)];  
566.                 List<triints> elmList = new List<triints>();  
567.                 TriInts wrkrElm = null;  
568.                 int nxtINTERP = 0;  
569.                 int lstINTERP = 0;  
570.                 Point3d arc_endpoint;  
571.                 for (int j = 0; j < pts.Length; j++)  
572.                 {  
573.                     if (j < pts.Length - 1)  
574.                         nxtINTERP = (blgs[j] == 0.0) ? SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleLine) : SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleLineAllCurves);  
575.   
576.                     if (lstINTERP != nxtINTERP)  
577.                     {  
578.                         if (wrkrElm != null)  
579.                             elmList.Add(wrkrElm);  
580.                         wrkrElm = new TriInts(ords_counter,  
581.                            SDO.BasicETYPE((blgs[j] == 0.0) ? DrawAbleSubComponentEType.SimpleLine : DrawAbleSubComponentEType.SimpleLineAllCurves),  
582.                            nxtINTERP);  
583.                         lstINTERP = nxtINTERP;  
584.                     }  
585.   
586.                     double theBulge = blgs[j];  
587.                     if (theBulge != 0.0)  
588.                     {  
589.                         arc_endpoint = pts[j + 1];  
590.                         CircularArc2d ca2d = new CircularArc2d(  
591.                             new Point2d(pts[j].X, pts[j].Y),  
592.                             new Point2d(arc_endpoint.X, arc_endpoint.Y), theBulge, false);  
593.   
594.                         Interval interval_of_arc = ca2d.GetInterval();  
595.                         Point2d somePointOnArc = ca2d.EvaluatePoint(interval_of_arc.Element / 2);  
596.                         //Start  
597.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);  
598.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);  
599.                         if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
600.                             dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);  
601.                         //Center point on arc  
602.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.X);  
603.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.Y);  
604.                         if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
605.                             dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);  
606.                     }  
607.                     else  
608.                     {  
609.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);  
610.                         dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);  
611.                         if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)  
612.                             dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);  
613.                     }  
614.   
615.                 }//for loop of ordinates  
616.                 int elem_cntr = 0;  
617.                 if (headerElem.ETYPE == SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine) ||  
618.                     headerElem.ETYPE == SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine))  
619.                 {  
620.                     //Add our last worker element  
621.                     elmList.Add(wrkrElm);  
622.                     //Update the count in the header  
623.                     headerElem.INTERP = elmList.Count;  
624.                     //Dimension the array = element list count +  one(1) for header "times" three(3)  
625.                     dlc.Elem = new int[(elmList.Count + 1) * 3];  
626.                     dlc.Elem[elem_cntr++] = headerElem.OFFSET;  
627.                     dlc.Elem[elem_cntr++] = headerElem.ETYPE;  
628.                     dlc.Elem[elem_cntr++] = headerElem.INTERP;  
629.                     for (int _i = 0; _i < elmList.Count; _i++)  
630.                     {  
631.                         dlc.Elem[elem_cntr++] = elmList[_i].OFFSET;  
632.                         dlc.Elem[elem_cntr++] = elmList[_i].ETYPE;  
633.                         dlc.Elem[elem_cntr++] = elmList[_i].INTERP;  
634.                     }  
635.                 }  
636.                 else  
637.                 {  
638.                     dlc.Elem = new int[3];  
639.                     dlc.Elem[elem_cntr++] = headerElem.OFFSET;  
640.                     dlc.Elem[elem_cntr++] = headerElem.ETYPE;  
641.                     dlc.Elem[elem_cntr++] = headerElem.INTERP;  
642.                 }  
643.                 dl.SubComponents.Add(dlc);  
644.             }//next ring in the MPolygon  
645.   
646.             return dl;  
647.         }  
648.         //  
649.         // Returns: List<dbpoint>, DBPoint, Polyline, MPolygon  
650.         //  
651.         public static object DrawAbleDwgObj(DrawAble drawable)  
652.         {  
653.             bool firstPointFlag = false;  
654.             int IncrementFor3d = 0;  
655.             if (drawable.Dimensionality == MDADDrawAbles.DrawAbleSdoGeometry.DefaultDimensionality3D)  
656.                 IncrementFor3d = 1;  
657.             MPolygon dbMpoly = null;  
658.             Polyline plineCurves = null;  
659.             Polyline plineCompound = null;  
660.             Polyline plineLine = null;  
661.             DBPoint dbPoint = null;  
662.             List<dbpoint> dbPointList = null;  
663.   
664.             //Turn the dim elements into triplets for easy use  
665.             List<triints> elmsList = null;  
666.             int CountOfComponents = drawable.SubComponents.Count;  
667.             foreach (DrawAbleSubComponent cmp in drawable.SubComponents)  
668.             {  
669.                 if (cmp.Elem != null)  
670.                 {  
671.                     elmsList = new List<triints>();  
672.                     for (int _i = 0; _i < cmp.Elem.Length; )  
673.                     {  
674.                         TriInts t = new TriInts(cmp.Elem[_i + 0], cmp.Elem[_i + 1], cmp.Elem[_i + 2]);  
675.                         elmsList.Add(t);  
676.                         _i = _i + 3;  
677.                     }  
678.                 }  
679.                 else  
680.                     elmsList = null;  
681.                 //Turn all the decimals into doubles  
682.                 double[] ords = new double[cmp.Ords.Length];  
683.                 for (int j = 0; j < cmp.Ords.Length; j++)  
684.                     ords[j] = System.Convert.ToDouble(cmp.Ords[j]);  
685.   
686.                 DrawAbleSubComponentEType etype = cmp.Etype;  
687.                 firstPointFlag = false;  
688.   
689.                 //  
690.                 //Compound components  
691.                 //These require a header and fixup of the components dim element array  
692.                 //  
693.                 if (cmp.Etype == DrawAbleSubComponentEType.CompoundLine ||  
694.                     cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine ||  
695.                     cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine)  
696.                 {  
697.                     CircularArc2d ca2d;  
698.                     Point2d firstPoint2d = new Point2d();  
699.                     Point2d begPoint2d = new Point2d();  
700.                     Point2d arrowPoint2d, endPoint2d;  
701.   
702.                     plineCompound = new Polyline();  
703.   
704.                     //We know what it is because of Etype. We just really need the INTERPs and OFFSETs. Skip to one(1)  
705.                     for (int _k = 1; _k < elmsList.Count; )  
706.                     {  
707.                         TriInts t = elmsList[_k]; int OFFSET = t.OFFSET; int ETYPE = t.ETYPE; int INTERP = t.INTERP;  
708.                         int nxtOFFSET = 0;  
709.                         if (_k < elmsList.Count - 1)  
710.                             nxtOFFSET = elmsList[_k + 1].OFFSET;  
711.                         else  
712.                             nxtOFFSET = ords.Length;  
713.                         for (int x = OFFSET; x < nxtOFFSET; )  
714.                         {  
715.                             double bulgeValue = 0.0;  
716.                             if (firstPointFlag == false) { firstPoint2d = new Point2d(ords[x], ords[x + 1]); firstPointFlag = true; }  
717.                             if (INTERP == 2)  
718.                             {  
719.                                 begPoint2d = new Point2d(ords[x++], ords[x++]); x = x + IncrementFor3d;  
720.                                 //Only if we are not at the end. We ended the line with an arc.  
721.                                 if (x < nxtOFFSET)  
722.                                 {  
723.                                     arrowPoint2d = new Point2d(ords[x++], ords[x++]); x = x + IncrementFor3d;  
724.                                     endPoint2d = new Point2d(ords[x], ords[x + 1]);  
725.                                     ca2d = new CircularArc2d(begPoint2d, arrowPoint2d, endPoint2d);  
726.                                     bulgeValue = GetBulge2d(ca2d);  
727.                                     ca2d.Dispose();  
728.                                 }  
729.                                 plineCompound.AddVertexAt(plineCompound.NumberOfVertices, begPoint2d, bulgeValue, 0, 0);  
730.                                 if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
731.                                     plineCompound.Elevation = ords[x - 1];  
732.                             }  
733.                             else  
734.                             {  
735.                                 begPoint2d = new Point2d(ords[x++], ords[x++]); x = x + IncrementFor3d;  
736.                                 plineCompound.AddVertexAt(plineCompound.NumberOfVertices, begPoint2d, 0.0, 0.0, 0.0);  
737.                                 if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
738.                                     plineCompound.Elevation = ords[x - 1];  
739.                             }  
740.                         }  
741.                         _k = _k + 1;  
742.                     }  
743.                     if (firstPoint2d == begPoint2d)  
744.                         plineCompound.Closed = true;  
745.   
746.                     if (cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine ||  
747.                         cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine)  
748.                     {  
749.                         if (dbMpoly == null)  
750.                         {  
751.                             dbMpoly = new MPolygon();  
752.                         }  
753.                         dbMpoly.AppendLoopFromBoundary(plineCompound, false, 0.005);  
754.                         dbMpoly.BalanceTree();  
755.                         plineCompound.Dispose();  
756.                         plineCompound = null;  
757.                     }  
758.                 }  
759.                 //  
760.                 //Point and PointCluster  
761.                 //  
762.                 if (cmp.Etype == DrawAbleSubComponentEType.Point)  
763.                 {  
764.                     Point3d p3d;  
765.                     if (IncrementFor3d == 1)  
766.                         p3d = new Point3d(ords[0], ords[1], ords[2]);  
767.                     else  
768.                         p3d = new Point3d(ords[0], ords[1], 0.0);  
769.                     dbPoint = new DBPoint(p3d);  
770.                 }  
771.                 else if (cmp.Etype == DrawAbleSubComponentEType.PointCluster)  
772.                     {  
773.                         Point3d p3d;  
774.                         dbPointList = new List<dbpoint>();  
775.   
776.                         for (int _x = 0; _x < ords.Length; )  
777.                         {  
778.                             if (IncrementFor3d == 1)  
779.                                 p3d = new Point3d(ords[_x++], ords[_x++], ords[_x++]);  
780.                             else  
781.                                 p3d = new Point3d(ords[_x++], ords[_x++], 0.0);  
782.                             dbPoint = new DBPoint(p3d);  
783.                             dbPointList.Add(dbPoint);  
784.                         }  
785.                     }  
786.                 //  
787.                 //Simple lines  
788.                 //  
789.                 if (cmp.Etype == DrawAbleSubComponentEType.SimpleLine ||  
790.                     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine ||  
791.                     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine)  
792.                 {  
793.                     Point2d begPoint2d = new Point2d();  
794.                     Point2d firstPoint2d = new Point2d();  
795.                     plineLine = new Polyline();  
796.   
797.                     for (int _x = 0; _x < ords.Length; )  
798.                     {  
799.                         if (firstPointFlag == false) { firstPoint2d = new Point2d(ords[0], ords[1]); firstPointFlag = true; }  
800.                         begPoint2d = new Point2d(ords[_x++], ords[_x++]); _x = _x + IncrementFor3d;  
801.                         plineLine.AddVertexAt(plineLine.NumberOfVertices, begPoint2d, 0.0, 0.0, 0.0);  
802.                         if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
803.                             plineLine.Elevation = ords[_x - 1];  
804.                     }  
805.                     if (firstPoint2d == begPoint2d)  
806.                         plineLine.Closed = true;  
807.   
808.                     if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine ||  
809.                         cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine)  
810.                     {  
811.                         if (dbMpoly == null)  
812.                         {  
813.                             dbMpoly = new MPolygon();  
814.                         }  
815.                         dbMpoly.AppendLoopFromBoundary(plineLine, false, 0.005);  
816.                         dbMpoly.BalanceTree();  
817.                         plineLine.Dispose();  
818.                         plineLine = null;  
819.                     }  
820.                 }  
821.                 //  
822.                 //Simple Curves  
823.                 //  
824.                 if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves ||  
825.                     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves ||  
826.                     cmp.Etype == DrawAbleSubComponentEType.SimpleLineAllCurves)  
827.                 {  
828.                     CircularArc2d ca2d;  
829.                     Point2d begPoint2d = new Point2d();  
830.                     Point2d firstPoint2d = new Point2d();  
831.                     Point2d arrowPoint2d, endPoint2d;  
832.                     plineCurves = new Polyline();  
833.                     //We know what it is because of Etype. We just really need the INTERPs and OFFSETs. Skip to one(1)  
834.                     for (int _x = 0; _x < ords.Length; )  
835.                     {  
836.                         if (firstPointFlag == false) { firstPoint2d = new Point2d(ords[0], ords[1]); firstPointFlag = true; }  
837.                         begPoint2d = new Point2d(ords[_x++], ords[_x++]); _x = _x + IncrementFor3d;  
838.                         double bulgeValue = 0.0;  
839.                         if (_x < ords.Length)  
840.                         {  
841.                             arrowPoint2d = new Point2d(ords[_x++], ords[_x++]); _x = _x + IncrementFor3d;  
842.                             endPoint2d = new Point2d(ords[_x], ords[_x + 1]);  
843.                             ca2d = new CircularArc2d(begPoint2d, arrowPoint2d, endPoint2d);  
844.                             bulgeValue = GetBulge2d(ca2d);  
845.                             ca2d.Dispose();  
846.                         }  
847.                         plineCurves.AddVertexAt(plineCurves.NumberOfVertices, begPoint2d, bulgeValue, 0, 0);  
848.                         if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
849.                             plineCurves.Elevation = ords[_x - 1];                         
850.                     }  
851.                     if (firstPoint2d == begPoint2d)  
852.                         plineCurves.Closed = true;  
853.   
854.                     if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves ||  
855.                         cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves)  
856.                     {  
857.                         if (dbMpoly == null)  
858.                         {  
859.                             dbMpoly = new MPolygon();  
860.                         }  
861.                         dbMpoly.AppendLoopFromBoundary(plineCurves, false, 0.005);  
862.                         dbMpoly.BalanceTree();  
863.                         plineCurves.Dispose();  
864.                         plineCurves = null;  
865.                     }  
866.                 }  
867.                 //  
868.                 // Circle  
869.                 //  
870.                 if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle ||  
871.                     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle)  
872.                 {  
873.                     Circle circleSurf = null;  
874.                     Point2d a = new Point2d(ords[0], ords[1]);  
875.                     Point2d b = new Point2d(ords[2 + IncrementFor3d], ords[3 + IncrementFor3d]);  
876.                     Point2d c = new Point2d(ords[4 + IncrementFor3d + IncrementFor3d], ords[5 + IncrementFor3d + IncrementFor3d]);  
877.                     double A = b.X - a.X;  
878.                     double B = b.Y - a.Y;  
879.                     double C = c.X - a.X;  
880.                     double D = c.Y - a.Y;  
881.   
882.                     double E = A * (a.X + b.X) + B * (a.Y + b.Y);  
883.                     double F = C * (a.X + c.X) + D * (a.Y + c.Y);  
884.                     double G = 2.0 * (A * (c.Y - b.Y) - B * (c.X - b.X));  
885.   
886.                     if (G != 0)  
887.                     {  
888.                         double pX = (D * E - B * F) / G;  
889.                         double pY = (A * F - C * E) / G;  
890.   
891.                         // r^2 = (a.X - pX) ^ 2.0 + (a.Y - pY) ^ 2.0  
892.                         double radiusSqd = Math.Pow((a.X - pX), 2.0) + Math.Pow((a.Y - pY), 2.0);  
893.                         double radius = Math.Sqrt(radiusSqd);  
894.   
895.                         Point3d p3d_center = new Point3d(pX, pY, 0.0);  
896.                         circleSurf = new Circle(p3d_center, new Vector3d(0.0, 0.0, 1.0), radius);  
897.                     }  
898.                     if (dbMpoly == null)  
899.                     {  
900.                         dbMpoly = new MPolygon();  
901.                     }  
902.                     dbMpoly.AppendLoopFromBoundary(circleSurf, false, 0.005);  
903.                     dbMpoly.BalanceTree();  
904.                     circleSurf.Dispose();  
905.                     circleSurf = null;  
906.                 }  
907.                 //  
908.                 //Rectangle  
909.                 //  
910.                 if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle ||  
911.                     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle)  
912.                 {  
913.                     Polyline plineRect = new Polyline();  
914.                     Point2d sw2d = new Point2d(ords[0], ords[1]);  
915.                     Point2d se2d = new Point2d(ords[2 + IncrementFor3d], ords[1]);  
916.                     Point2d ne2d = new Point2d(ords[2 + IncrementFor3d], ords[3 + IncrementFor3d]);  
917.                     Point2d nw2d = new Point2d(ords[0], ords[3 + IncrementFor3d]);  
918.                     Point2d closer2d = new Point2d(ords[0], ords[1]);  
919.                     plineRect.AddVertexAt(plineRect.NumberOfVertices, sw2d, 0.0, 0.0, 0.0);  
920.                     plineRect.AddVertexAt(plineRect.NumberOfVertices, se2d, 0.0, 0.0, 0.0);  
921.                     plineRect.AddVertexAt(plineRect.NumberOfVertices, ne2d, 0.0, 0.0, 0.0);  
922.                     plineRect.AddVertexAt(plineRect.NumberOfVertices, nw2d, 0.0, 0.0, 0.0);  
923.                     plineRect.AddVertexAt(plineRect.NumberOfVertices, closer2d, 0.0, 0.0, 0.0);  
924.                     plineRect.Closed = true;  
925.                     if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)  
926.                         plineRect.Elevation = ords[2];  
927.                     if (dbMpoly == null)  
928.                     {  
929.                         dbMpoly = new MPolygon();  
930.                     }  
931.                     dbMpoly.AppendLoopFromBoundary(plineRect, false, 0.005);  
932.                     dbMpoly.BalanceTree();  
933.                     plineRect.Dispose();  
934.                     plineRect = null;  
935.                 }  
936.    
937.             }//Do the next subcomponent  
938.             if (dbMpoly != null)  
939.                 return (object)dbMpoly;  
940.             else if (dbPointList != null)  
941.                 return (object)dbPointList;  
942.             else if (dbPoint != null)  
943.                 return (object)dbPoint;  
944.             else if (plineLine != null)  
945.                 return (object)plineLine;  
946.             else if (plineCurves != null)  
947.                 return (object)plineCurves;  
948.             else if (plineCompound != null)  
949.                 return (object)plineCompound;  
950.             else  
951.                 return null;  
952.   
953.         }  
954.       
955.         public static double GetBulge2d(CircularArc2d ca2d)  
956.         {  
957.             double theBulge = 0.0;  
958.             if (ca2d.IsClockWise == true)  
959.             {  
960.                 theBulge = -Math.Tan((ca2d.EndAngle - ca2d.StartAngle) / 4);  
961.             }  
962.             else  
963.             {  
964.                 theBulge = Math.Tan((ca2d.EndAngle - ca2d.StartAngle) / 4);  
965.             }  
966.             return theBulge;  
967.         }  
968.   
969.     }//eoc DrawAbleDwg  
970. }//eons  
971. </dbpoint></triints></triints></dbpoint></dbpoint></triints></triints></triints></triints></point3d>  

using MDADDrawAbles;
using SDO = MDADDrawAbles.DrawAbleSdoGeometryUtil;

using NetSdoGeometry;

namespace MDADDrawAbleDwg
{
    public class DrawAbleDwg
    {
        //
        // POINT
        //
        public static DrawAble PointDrawAbleFromPoint(Point3d p3d, int _dimensionality)
        {
            DrawAble dp = new DrawAble(DrawAbleType.Point, _dimensionality);
            DrawAbleSubComponent dpc = new DrawAbleSubComponent();
            dpc.Etype = DrawAbleSubComponentEType.Point;
            int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
            dpc.Ords = new decimal[len];
            dpc.Ords[0] = System.Convert.ToDecimal(p3d.X);
            dpc.Ords[1] = System.Convert.ToDecimal(p3d.Y);
            if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dpc.Ords[2] = System.Convert.ToDecimal(p3d.Z);
            dp.SubComponents.Add(dpc);
            return dp;
        }
        public static DrawAble PointDrawAbleFromPoint(DBPoint dbp, int _dimensionality)
        {
            DrawAble dp = new DrawAble(DrawAbleType.Point, _dimensionality);
            DrawAbleSubComponent dpc = new DrawAbleSubComponent();
            dpc.Etype = DrawAbleSubComponentEType.Point;
            int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
            dpc.Ords = new decimal[len];
            dpc.Ords[0] = System.Convert.ToDecimal(dbp.Position.X);
            dpc.Ords[1] = System.Convert.ToDecimal(dbp.Position.Y);
            if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dpc.Ords[2] = System.Convert.ToDecimal(dbp.Position.Z);
            dp.SubComponents.Add(dpc);
            return dp;
        }
        //
        // POINT CLUSTER
        //
        public static DrawAble PointClusterDrawAbleFromPointList(List p3dList, int _dimensionality)
        {
            DrawAble dp = new DrawAble(DrawAbleType.Point, _dimensionality);
            DrawAbleSubComponent dpc = new DrawAbleSubComponent();
            dpc.Etype = DrawAbleSubComponentEType.PointCluster;
            int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
            dpc.Ords = new decimal[len * p3dList.Count];
            int p3d_counter = 0;
            for (int _k = 0; _k < dpc.Ords.Length; )
            {
                dpc.Ords[_k] = System.Convert.ToDecimal(p3dList[p3d_counter].X);
                dpc.Ords[_k + 1] = System.Convert.ToDecimal(p3dList[p3d_counter].Y);
                if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                    dpc.Ords[_k + 2] = System.Convert.ToDecimal(p3dList[p3d_counter].Z);
                _k = _k + len;
                p3d_counter = p3d_counter + 1;
            }
            dpc.Elem = new int[] { 0, 1, p3dList.Count };
            dp.SubComponents.Add(dpc);
            return dp;
        }
        //
        // LINES
        //
        public static DrawAble LineCurveDrawAbleFromPolyline(Polyline pl, Polyline2d pl2d, Polyline3d pl3d, int _dimensionality)
        {
            DrawAble dl = new DrawAble(DrawAbleType.Line, _dimensionality);
            int hasBulgesCount = 0;
            Point3dCollection tmppts = null;
            DoubleCollection tmpblgs = null;
            Point3d[] pts = null;
            double[] blgs = null;
            if (pl != null)
            {
                tmppts = new Point3dCollection();
                tmpblgs = new DoubleCollection();
                int i = 0;
                for (; i < pl.NumberOfVertices; i++)
                {
                    switch (pl.GetSegmentType(i))
                    {
                        case SegmentType.Arc:
                            CircularArc2d ca2d = pl.GetArcSegment2dAt(i);
                            double bulge = GetBulge2d(ca2d);
                            tmpblgs.Add(bulge);
                            tmppts.Add(new Point3d(ca2d.StartPoint.X, ca2d.StartPoint.Y, pl.GetPoint3dAt(i).Z));
                            hasBulgesCount++;
                            ca2d.Dispose();
                            break;
                        default:
                            tmpblgs.Add(0.0);
                            tmppts.Add(new Point3d(pl.GetPoint3dAt(i).X, pl.GetPoint3dAt(i).Y, pl.GetPoint3dAt(i).Z));
                            break;
                    }
                }
                // Do NOT duplicate any point ... this appears to have different behavior for 
                // the 2D and 3D polylines so we will check them all.
                if (pl.Closed && (tmppts[0].IsEqualTo(tmppts[tmppts.Count - 1]) == false))
                {
                    //tmppts.Add(new Point3d(pl.GetPoint2dAt(0).X, pl.GetPoint2dAt(0).Y, 0.0));
                    tmppts.Add(new Point3d(pl.GetPoint3dAt(0).X, pl.GetPoint3dAt(0).Y, pl.GetPoint3dAt(0).Z));
                    tmpblgs.Add(0.0);
                }
                // Now we can dimensions our array stuctures and fill them up
                pts = new Point3d[tmppts.Count];
                blgs = new double[tmppts.Count];
                for (int z = 0; z < tmppts.Count; z++)
                {
                    pts[z] = new Point3d(tmppts[z].X, tmppts[z].Y, tmppts[z].Z);
                    blgs[z] = tmpblgs[z];
                }
                tmppts.Clear();
                tmppts.Dispose();
                tmpblgs.Clear();
            }
            //END OF POLYLINE
            //START OF POLYLINE2D
            if (pl2d != null)
            {
                // No way of knowing how many we have so we need this to collect the points
                tmppts = new Point3dCollection();
                tmpblgs = new DoubleCollection();
                if (pl2d.PolyType == Poly2dType.SimplePoly)
                {
                    Transaction t = pl2d.Database.TransactionManager.StartTransaction();
                    IEnumerator iterate = pl2d.GetEnumerator();
                    while (iterate.MoveNext())
                    {
                        ObjectId id = (ObjectId)iterate.Current;
                        Vertex2d vertex = (Vertex2d)t.GetObject(id, OpenMode.ForRead);
                        tmppts.Add(vertex.Position);
                        tmpblgs.Add(vertex.Bulge);
                        if (vertex.Bulge != 0.0)
                            hasBulgesCount++;
                    }
                    t.Abort();
                    t.Dispose();
                }
                else
                {
                    DBObjectCollection collection = new DBObjectCollection();
                    pl2d.Explode(collection);
                    foreach (Line line in collection)
                    {
                        tmppts.Add(line.StartPoint);
                        tmpblgs.Add(0.0);
                        tmppts.Add(line.EndPoint);
                        tmpblgs.Add(0.0);
                    }
                    collection.Dispose();
                }
                // Do NOT duplicate any point
                if (pl2d.Closed && (tmppts[0].IsEqualTo(tmppts[tmppts.Count - 1]) == false))
                {
                    tmppts.Add(tmppts[0]);
                    tmpblgs.Add(0.0);
                }
                // Now we can dimensions our array stuctures and fill them up
                pts = new Point3d[tmppts.Count];
                blgs = new double[tmppts.Count];
                for (int z = 0; z < tmppts.Count; z++)
                {
                    pts[z] = new Point3d(tmppts[z].X, tmppts[z].Y, tmppts[z].Z);
                    blgs[z] = tmpblgs[z];
                }
                tmppts.Clear();
                tmppts.Dispose();
                tmpblgs.Clear();
            }
            //END OF POLYLINE2D
            //START OF POLYLINE3D
            if (pl3d != null)
            {
                tmppts = new Point3dCollection();
                tmpblgs = new DoubleCollection();
                if (pl3d.PolyType == Poly3dType.SimplePoly)
                {
                    Transaction t = pl3d.Database.TransactionManager.StartTransaction();
                    IEnumerator iterator = pl3d.GetEnumerator();
                    while (iterator.MoveNext())
                    {
                        ObjectId id = (ObjectId)iterator.Current;
                        PolylineVertex3d vertex3d = (PolylineVertex3d)t.GetObject(id, OpenMode.ForRead);
                        tmppts.Add(vertex3d.Position);
                        tmpblgs.Add(0.0);
                    }
                    t.Abort();
                    t.Dispose();
                }
                else
                {
                    DBObjectCollection collection = new DBObjectCollection();
                    pl3d.Explode(collection);
                    foreach (Line line in collection)
                    {
                        tmppts.Add(line.StartPoint);
                        tmpblgs.Add(0.0);
                        tmppts.Add(line.EndPoint);
                        tmpblgs.Add(0.0);
                    }
                    collection.Dispose();
                }
                // Do NOT duplicate any point
                if (pl3d.Closed && (tmppts[0].IsEqualTo(tmppts[tmppts.Count - 1]) == false))
                {
                    tmppts.Add(tmppts[0]);
                    tmpblgs.Add(0.0);
                }
                // Now we can dimensions our array stuctures and fill them up
                pts = new Point3d[tmppts.Count];
                blgs = new double[tmppts.Count];
                for (int z = 0; z < tmppts.Count; z++)
                {
                    pts[z] = new Point3d(tmppts[z].X, tmppts[z].Y, tmppts[z].Z);
                    blgs[z] = tmpblgs[z];
                }
                tmppts.Clear();
                tmppts.Dispose();
                tmpblgs.Clear();
            }
            //END OF POLYLINE3D
            //
            // Finished getting all the ordinates and bulges for this linecurve
            //
            DrawAbleSubComponent dlc = new DrawAbleSubComponent();
            if (hasBulgesCount == 0)
            {
                dlc.Etype = DrawAbleSubComponentEType.SimpleLine;
                int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
                dlc.Ords = new decimal[len * pts.Length];
                int pts_counter = 0;
                for (int _k = 0; _k < dlc.Ords.Length; )
                {
                    dlc.Ords[_k] = System.Convert.ToDecimal(pts[pts_counter].X);
                    dlc.Ords[_k + 1] = System.Convert.ToDecimal(pts[pts_counter].Y);
                    if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                        dlc.Ords[_k + 2] = System.Convert.ToDecimal(pts[pts_counter].Z);
                    _k = _k + len;
                    pts_counter = pts_counter + 1;
                }
                dl.SubComponents.Add(dlc);
            }
            else if (hasBulgesCount == pts.Length - 1)
            {
                dlc.Etype = DrawAbleSubComponentEType.SimpleLineAllCurves;
                int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
                dlc.Ords = new decimal[(len * pts.Length) + (hasBulgesCount * len)];
                int ords_counter = 0;
                Point3d arc_endpoint;

                for (int j = 0; j < pts.Length; j++)
                {
                    double theBulge = blgs[j];
                    arc_endpoint = pts[j + 1];
                    CircularArc2d ca2d = new CircularArc2d(
                        new Point2d(pts[j].X, pts[j].Y),
                        new Point2d(arc_endpoint.X, arc_endpoint.Y), theBulge, false);

                    Interval interval_of_arc = ca2d.GetInterval();
                    Point2d somePointOnArc = ca2d.EvaluatePoint(interval_of_arc.Element / 2);
                    //Start
                    dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);
                    dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);
                    if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);
                    //Center point on arc
                    dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.X);
                    dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.Y);
                    if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);

                    //Because of LOOK-AHEAD we now check for the end
                    if (j == (pts.Length - 2))
                    {
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(arc_endpoint.X);
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(arc_endpoint.Y);
                        if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            dlc.Ords[ords_counter++] = System.Convert.ToDecimal(arc_endpoint.Z);
                        j = pts.Length; //End the loop
                    }
                }
                dl.SubComponents.Add(dlc);
            }
            else
            {
                //DIM_ELEMENTS are required
                dlc.Etype = DrawAbleSubComponentEType.CompoundLine;
                int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
                dlc.Ords = new decimal[(len * pts.Length) + (hasBulgesCount * len)];
                int ords_counter = 0;
                Point3d arc_endpoint;

                TriInts elmHeader = new TriInts(ords_counter, SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundLine), 0);
                List elmList = new List();
                TriInts wrkrElm = null;
                int nxtINTERP = 0;
                int lstINTERP = 0;
                for (int j = 0; j < pts.Length; j++)
                {
                    if (j < pts.Length - 1)
                        nxtINTERP = (blgs[j] == 0.0) ? (int)SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleLine) : (int)SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleLineAllCurves);

                    if (lstINTERP != nxtINTERP)
                    {
                        if (wrkrElm != null)
                            elmList.Add(wrkrElm);
                        wrkrElm = new TriInts(ords_counter, SDO.BasicETYPE(DrawAbleSubComponentEType.SimpleLineAllCurves), nxtINTERP);
                        lstINTERP = nxtINTERP;
                    }

                    double theBulge = blgs[j];
                    if (theBulge != 0.0)
                    {
                        arc_endpoint = pts[j + 1];
                        CircularArc2d ca2d = new CircularArc2d(
                            new Point2d(pts[j].X, pts[j].Y),
                            new Point2d(arc_endpoint.X, arc_endpoint.Y), theBulge, false);

                        Interval interval_of_arc = ca2d.GetInterval();
                        Point2d somePointOnArc = ca2d.EvaluatePoint(interval_of_arc.Element / 2);
                        //Start
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);
                        if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);
                        //Center point on arc
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.X);
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.Y);
                        if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);
                    }
                    else
                    {
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);
                        if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);
                    }

                }//for loop
                elmList.Add(wrkrElm);
                elmHeader.INTERP = elmList.Count;
                dlc.Elem = new int[(elmList.Count + 1) * 3];
                int cntr = 0;
                dlc.Elem[cntr++] = elmHeader.OFFSET;
                dlc.Elem[cntr++] = elmHeader.ETYPE;
                dlc.Elem[cntr++] = elmHeader.INTERP;
                for (int _i = 0; _i < elmList.Count; _i++)
                {
                    dlc.Elem[cntr++] = elmList[_i].OFFSET;
                    dlc.Elem[cntr++] = elmList[_i].ETYPE;
                    dlc.Elem[cntr++] = elmList[_i].INTERP;
                }
                dl.SubComponents.Add(dlc);
            }
            return dl;
        }
        public static DrawAble LineCurveDrawAbleFromArc(Arc a, int _dimensionality)
        {
            DrawAble d = new DrawAble(DrawAbleType.Line, _dimensionality);
            DrawAbleSubComponent dc = new DrawAbleSubComponent();
            dc.Etype = DrawAbleSubComponentEType.SimpleLineAllCurves;
            int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
            dc.Ords = new decimal[len * 3];
            double length = a.GetDistAtPoint(a.EndPoint);
            Point3d mid = a.GetPointAtDist(length / 2.0);
            int ords_counter = 0;
            //Start
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.StartPoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.StartPoint.Y);
            if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.StartPoint.Z);
            //Mid
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(mid.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(mid.Y);
            if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(mid.Z);
            //End
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.EndPoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.EndPoint.Y);
            if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(a.EndPoint.Z);
            d.SubComponents.Add(dc);

            return d;
        }
        public static DrawAble LineCurveDrawAbleFromLine(Line l, int _dimensionality)
        {
            DrawAble d = new DrawAble(DrawAbleType.Line, _dimensionality);
            DrawAbleSubComponent dc = new DrawAbleSubComponent();
            dc.Etype = DrawAbleSubComponentEType.SimpleLine;
            int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
            dc.Ords = new decimal[len * 2];
            int ords_counter = 0;
            //Start
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.StartPoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.StartPoint.Y);
            if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.StartPoint.Z);
            //End
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.EndPoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.EndPoint.Y);
            if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(l.EndPoint.Z);
            d.SubComponents.Add(dc);

            return d;
        }
        public static DrawAble LineCurveDrawAbleFromCircle(Circle circ, int _dimensionality)
        {
            DrawAble d = new DrawAble(DrawAbleType.Line, _dimensionality);
            DrawAbleSubComponent dc = new DrawAbleSubComponent();
            dc.Etype = DrawAbleSubComponentEType.SimpleLineAllCurves;
            int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? 15 : 10;         
            dc.Ords = new decimal[len];
            int ords_counter = 0;            
            double length = circ.Circumference;
            Point3d firstarc_endpoint = circ.GetPointAtDist(length / 2.0);
            Point3d firstarc_midpoint = circ.GetPointAtDist((length / 2.0) / 2.0);
            Point3d secondarc_midpoint = circ.GetPointAtDist(length * .75);
            //Start
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.StartPoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.StartPoint.Y);
            if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.StartPoint.Z);
            //mid 1
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_midpoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_midpoint.Y);
            if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_midpoint.Z);
            //End
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_endpoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_endpoint.Y);
            if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(firstarc_endpoint.Z);
            //mid 2
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(secondarc_midpoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(secondarc_midpoint.Y);
            if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(secondarc_midpoint.Z);
            //End
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.EndPoint.X);
            dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.EndPoint.Y);
            if (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                dc.Ords[ords_counter++] = System.Convert.ToDecimal(circ.EndPoint.Z);

            d.SubComponents.Add(dc);

            return d;
        }
        //
        // SURFACES
        //
        public static DrawAble PolygonDrawAbleFromMPolygon(MPolygon mpoly, int _dimensionality)
        {
            DrawAble dl = new DrawAble(DrawAbleType.Surface, _dimensionality);
            Point3dCollection p3dColl = new Point3dCollection();
            LoopDirection loopdirection;
            int ords_counter = 0;                           // The total ordinates in the array
            int hasBulgesCount = 0;
            int loops = mpoly.NumMPolygonLoops;
            for (int i = 0; i < loops; i++)
            {
                // Gather up points and bulges for this loop
                MPolygonLoop mPolygonLoop = mpoly.GetMPolygonLoopAt(i);
                loopdirection = mpoly.GetLoopDirection(i);
                hasBulgesCount = 0;
                ords_counter = 0;
                // Remove duplicate verticies
                for (int d = 1; d < mPolygonLoop.Count - 1; d++)
                {
                    if (mPolygonLoop[d].Vertex.IsEqualTo(mPolygonLoop[d + 1].Vertex))
                    {
                        mPolygonLoop.RemoveAt(d + 1);
                    }
                }
                //
                Point3d[] pts = new Point3d[mPolygonLoop.Count];
                double[] blgs = new double[mPolygonLoop.Count];
                for (int z = 0; z < mPolygonLoop.Count; z++)
                {
                    if (z == mPolygonLoop.Count - 1)
                    {
                        pts[z] = pts[0];
                    }
                    else
                    {
                        double X = Math.Round(mPolygonLoop[z].Vertex.X, 10, MidpointRounding.AwayFromZero);
                        double Y = Math.Round(mPolygonLoop[z].Vertex.Y, 10, MidpointRounding.AwayFromZero);
                        double Z = Math.Round(mpoly.Elevation, 10, MidpointRounding.AwayFromZero);
                        pts[z] = new Point3d(X, Y, Z);
                    }
                    blgs[z] = mPolygonLoop[z].Bulge;
                    if (blgs[z] != 0.0)
                        hasBulgesCount = hasBulgesCount + 1;
                }
                //
                // Suspect code here ......
                //
                if (blgs[0] == blgs[mPolygonLoop.Count - 1] && blgs[0] != 0.0)
                {
                    blgs[mPolygonLoop.Count - 1] = 0.0;
                    hasBulgesCount--;
                }
                //
                //DO THE STUFF
                //
                DrawAbleSubComponent dlc = new DrawAbleSubComponent();
                TriInts headerElem = new TriInts(ords_counter, 0, 0);
                if (hasBulgesCount == 0)
                {
                    headerElem.INTERP = SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine);
                }
                //else if (hasBulgesCount == pts.Length)
                else if (hasBulgesCount == pts.Length - 1)
                {
                    headerElem.INTERP = SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves);
                }

                if (loopdirection == LoopDirection.Exterior)
                {
                    if (headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine) ||
                        headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves))
                    {
                        headerElem.ETYPE = SDO.BasicETYPE(DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine);
                        if (headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine))
                            dlc.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine;
                        else
                            dlc.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves;
                    }
                }
                else
                {

                    if (headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine) ||
                        headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves))
                    {
                        headerElem.ETYPE = SDO.BasicETYPE(DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine);
                        if (headerElem.INTERP == SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine))
                            dlc.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine;
                        else
                            dlc.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves;
                    }
                }
                // If we have not set the etype it must be a 1005 0R 2005 - compound polygon
                if (headerElem.ETYPE == 0 && hasBulgesCount > 0)
                {
                    if (loopdirection == LoopDirection.Exterior)
                    {
                        headerElem.ETYPE = SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine);
                        dlc.Etype = DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine;
                    }
                    else
                    {
                        headerElem.ETYPE = SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine);
                        dlc.Etype = DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine;
                    }
                    headerElem.INTERP = 0; // to be set later with count
                }
                //Now we are ready to build the elem and ords
                int len = (_dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D) ? DrawAbleSdoGeometry.DefaultDimensionality3D : DrawAbleSdoGeometry.DefaultDimensionality2D;
                dlc.Ords = new decimal[(len * pts.Length) + (hasBulgesCount * len)];
                List elmList = new List();
                TriInts wrkrElm = null;
                int nxtINTERP = 0;
                int lstINTERP = 0;
                Point3d arc_endpoint;
                for (int j = 0; j < pts.Length; j++)
                {
                    if (j < pts.Length - 1)
                        nxtINTERP = (blgs[j] == 0.0) ? SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleLine) : SDO.BasicINTERPRETATION(DrawAbleSubComponentEType.SimpleLineAllCurves);

                    if (lstINTERP != nxtINTERP)
                    {
                        if (wrkrElm != null)
                            elmList.Add(wrkrElm);
                        wrkrElm = new TriInts(ords_counter,
                           SDO.BasicETYPE((blgs[j] == 0.0) ? DrawAbleSubComponentEType.SimpleLine : DrawAbleSubComponentEType.SimpleLineAllCurves),
                           nxtINTERP);
                        lstINTERP = nxtINTERP;
                    }

                    double theBulge = blgs[j];
                    if (theBulge != 0.0)
                    {
                        arc_endpoint = pts[j + 1];
                        CircularArc2d ca2d = new CircularArc2d(
                            new Point2d(pts[j].X, pts[j].Y),
                            new Point2d(arc_endpoint.X, arc_endpoint.Y), theBulge, false);

                        Interval interval_of_arc = ca2d.GetInterval();
                        Point2d somePointOnArc = ca2d.EvaluatePoint(interval_of_arc.Element / 2);
                        //Start
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);
                        if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);
                        //Center point on arc
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.X);
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(somePointOnArc.Y);
                        if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);
                    }
                    else
                    {
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].X);
                        dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Y);
                        if (len == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            dlc.Ords[ords_counter++] = System.Convert.ToDecimal(pts[j].Z);
                    }

                }//for loop of ordinates
                int elem_cntr = 0;
                if (headerElem.ETYPE == SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine) ||
                    headerElem.ETYPE == SDO.BasicETYPE(DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine))
                {
                    //Add our last worker element
                    elmList.Add(wrkrElm);
                    //Update the count in the header
                    headerElem.INTERP = elmList.Count;
                    //Dimension the array = element list count +  one(1) for header "times" three(3)
                    dlc.Elem = new int[(elmList.Count + 1) * 3];
                    dlc.Elem[elem_cntr++] = headerElem.OFFSET;
                    dlc.Elem[elem_cntr++] = headerElem.ETYPE;
                    dlc.Elem[elem_cntr++] = headerElem.INTERP;
                    for (int _i = 0; _i < elmList.Count; _i++)
                    {
                        dlc.Elem[elem_cntr++] = elmList[_i].OFFSET;
                        dlc.Elem[elem_cntr++] = elmList[_i].ETYPE;
                        dlc.Elem[elem_cntr++] = elmList[_i].INTERP;
                    }
                }
                else
                {
                    dlc.Elem = new int[3];
                    dlc.Elem[elem_cntr++] = headerElem.OFFSET;
                    dlc.Elem[elem_cntr++] = headerElem.ETYPE;
                    dlc.Elem[elem_cntr++] = headerElem.INTERP;
                }
                dl.SubComponents.Add(dlc);
            }//next ring in the MPolygon

            return dl;
        }
        //
        // Returns: List, DBPoint, Polyline, MPolygon
        //
        public static object DrawAbleDwgObj(DrawAble drawable)
        {
            bool firstPointFlag = false;
            int IncrementFor3d = 0;
            if (drawable.Dimensionality == MDADDrawAbles.DrawAbleSdoGeometry.DefaultDimensionality3D)
                IncrementFor3d = 1;
            MPolygon dbMpoly = null;
            Polyline plineCurves = null;
            Polyline plineCompound = null;
            Polyline plineLine = null;
            DBPoint dbPoint = null;
            List dbPointList = null;

            //Turn the dim elements into triplets for easy use
            List elmsList = null;
            int CountOfComponents = drawable.SubComponents.Count;
            foreach (DrawAbleSubComponent cmp in drawable.SubComponents)
            {
                if (cmp.Elem != null)
                {
                    elmsList = new List();
                    for (int _i = 0; _i < cmp.Elem.Length; )
                    {
                        TriInts t = new TriInts(cmp.Elem[_i + 0], cmp.Elem[_i + 1], cmp.Elem[_i + 2]);
                        elmsList.Add(t);
                        _i = _i + 3;
                    }
                }
                else
                    elmsList = null;
                //Turn all the decimals into doubles
                double[] ords = new double[cmp.Ords.Length];
                for (int j = 0; j < cmp.Ords.Length; j++)
                    ords[j] = System.Convert.ToDouble(cmp.Ords[j]);

                DrawAbleSubComponentEType etype = cmp.Etype;
                firstPointFlag = false;

                //
                //Compound components
                //These require a header and fixup of the components dim element array
                //
                if (cmp.Etype == DrawAbleSubComponentEType.CompoundLine ||
                    cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine ||
                    cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine)
                {
                    CircularArc2d ca2d;
                    Point2d firstPoint2d = new Point2d();
                    Point2d begPoint2d = new Point2d();
                    Point2d arrowPoint2d, endPoint2d;

                    plineCompound = new Polyline();

                    //We know what it is because of Etype. We just really need the INTERPs and OFFSETs. Skip to one(1)
                    for (int _k = 1; _k < elmsList.Count; )
                    {
                        TriInts t = elmsList[_k]; int OFFSET = t.OFFSET; int ETYPE = t.ETYPE; int INTERP = t.INTERP;
                        int nxtOFFSET = 0;
                        if (_k < elmsList.Count - 1)
                            nxtOFFSET = elmsList[_k + 1].OFFSET;
                        else
                            nxtOFFSET = ords.Length;
                        for (int x = OFFSET; x < nxtOFFSET; )
                        {
                            double bulgeValue = 0.0;
                            if (firstPointFlag == false) { firstPoint2d = new Point2d(ords[x], ords[x + 1]); firstPointFlag = true; }
                            if (INTERP == 2)
                            {
                                begPoint2d = new Point2d(ords[x++], ords[x++]); x = x + IncrementFor3d;
                                //Only if we are not at the end. We ended the line with an arc.
                                if (x < nxtOFFSET)
                                {
                                    arrowPoint2d = new Point2d(ords[x++], ords[x++]); x = x + IncrementFor3d;
                                    endPoint2d = new Point2d(ords[x], ords[x + 1]);
                                    ca2d = new CircularArc2d(begPoint2d, arrowPoint2d, endPoint2d);
                                    bulgeValue = GetBulge2d(ca2d);
                                    ca2d.Dispose();
                                }
                                plineCompound.AddVertexAt(plineCompound.NumberOfVertices, begPoint2d, bulgeValue, 0, 0);
                                if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                                    plineCompound.Elevation = ords[x - 1];
                            }
                            else
                            {
                                begPoint2d = new Point2d(ords[x++], ords[x++]); x = x + IncrementFor3d;
                                plineCompound.AddVertexAt(plineCompound.NumberOfVertices, begPoint2d, 0.0, 0.0, 0.0);
                                if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                                    plineCompound.Elevation = ords[x - 1];
                            }
                        }
                        _k = _k + 1;
                    }
                    if (firstPoint2d == begPoint2d)
                        plineCompound.Closed = true;

                    if (cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine ||
                        cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine)
                    {
                        if (dbMpoly == null)
                        {
                            dbMpoly = new MPolygon();
                        }
                        dbMpoly.AppendLoopFromBoundary(plineCompound, false, 0.005);
                        dbMpoly.BalanceTree();
                        plineCompound.Dispose();
                        plineCompound = null;
                    }
                }
                //
                //Point and PointCluster
                //
                if (cmp.Etype == DrawAbleSubComponentEType.Point)
                {
                    Point3d p3d;
                    if (IncrementFor3d == 1)
                        p3d = new Point3d(ords[0], ords[1], ords[2]);
                    else
                        p3d = new Point3d(ords[0], ords[1], 0.0);
                    dbPoint = new DBPoint(p3d);
                }
                else if (cmp.Etype == DrawAbleSubComponentEType.PointCluster)
                    {
                        Point3d p3d;
                        dbPointList = new List();

                        for (int _x = 0; _x < ords.Length; )
                        {
                            if (IncrementFor3d == 1)
                                p3d = new Point3d(ords[_x++], ords[_x++], ords[_x++]);
                            else
                                p3d = new Point3d(ords[_x++], ords[_x++], 0.0);
                            dbPoint = new DBPoint(p3d);
                            dbPointList.Add(dbPoint);
                        }
                    }
                //
                //Simple lines
                //
                if (cmp.Etype == DrawAbleSubComponentEType.SimpleLine ||
                    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine ||
                    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine)
                {
                    Point2d begPoint2d = new Point2d();
                    Point2d firstPoint2d = new Point2d();
                    plineLine = new Polyline();

                    for (int _x = 0; _x < ords.Length; )
                    {
                        if (firstPointFlag == false) { firstPoint2d = new Point2d(ords[0], ords[1]); firstPointFlag = true; }
                        begPoint2d = new Point2d(ords[_x++], ords[_x++]); _x = _x + IncrementFor3d;
                        plineLine.AddVertexAt(plineLine.NumberOfVertices, begPoint2d, 0.0, 0.0, 0.0);
                        if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            plineLine.Elevation = ords[_x - 1];
                    }
                    if (firstPoint2d == begPoint2d)
                        plineLine.Closed = true;

                    if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine ||
                        cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine)
                    {
                        if (dbMpoly == null)
                        {
                            dbMpoly = new MPolygon();
                        }
                        dbMpoly.AppendLoopFromBoundary(plineLine, false, 0.005);
                        dbMpoly.BalanceTree();
                        plineLine.Dispose();
                        plineLine = null;
                    }
                }
                //
                //Simple Curves
                //
                if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves ||
                    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves ||
                    cmp.Etype == DrawAbleSubComponentEType.SimpleLineAllCurves)
                {
                    CircularArc2d ca2d;
                    Point2d begPoint2d = new Point2d();
                    Point2d firstPoint2d = new Point2d();
                    Point2d arrowPoint2d, endPoint2d;
                    plineCurves = new Polyline();
                    //We know what it is because of Etype. We just really need the INTERPs and OFFSETs. Skip to one(1)
                    for (int _x = 0; _x < ords.Length; )
                    {
                        if (firstPointFlag == false) { firstPoint2d = new Point2d(ords[0], ords[1]); firstPointFlag = true; }
                        begPoint2d = new Point2d(ords[_x++], ords[_x++]); _x = _x + IncrementFor3d;
                        double bulgeValue = 0.0;
                        if (_x < ords.Length)
                        {
                            arrowPoint2d = new Point2d(ords[_x++], ords[_x++]); _x = _x + IncrementFor3d;
                            endPoint2d = new Point2d(ords[_x], ords[_x + 1]);
                            ca2d = new CircularArc2d(begPoint2d, arrowPoint2d, endPoint2d);
                            bulgeValue = GetBulge2d(ca2d);
                            ca2d.Dispose();
                        }
                        plineCurves.AddVertexAt(plineCurves.NumberOfVertices, begPoint2d, bulgeValue, 0, 0);
                        if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                            plineCurves.Elevation = ords[_x - 1];                       
                    }
                    if (firstPoint2d == begPoint2d)
                        plineCurves.Closed = true;

                    if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves ||
                        cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves)
                    {
                        if (dbMpoly == null)
                        {
                            dbMpoly = new MPolygon();
                        }
                        dbMpoly.AppendLoopFromBoundary(plineCurves, false, 0.005);
                        dbMpoly.BalanceTree();
                        plineCurves.Dispose();
                        plineCurves = null;
                    }
                }
                //
                // Circle
                //
                if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle ||
                    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle)
                {
                    Circle circleSurf = null;
                    Point2d a = new Point2d(ords[0], ords[1]);
                    Point2d b = new Point2d(ords[2 + IncrementFor3d], ords[3 + IncrementFor3d]);
                    Point2d c = new Point2d(ords[4 + IncrementFor3d + IncrementFor3d], ords[5 + IncrementFor3d + IncrementFor3d]);
                    double A = b.X - a.X;
                    double B = b.Y - a.Y;
                    double C = c.X - a.X;
                    double D = c.Y - a.Y;

                    double E = A * (a.X + b.X) + B * (a.Y + b.Y);
                    double F = C * (a.X + c.X) + D * (a.Y + c.Y);
                    double G = 2.0 * (A * (c.Y - b.Y) - B * (c.X - b.X));

                    if (G != 0)
                    {
                        double pX = (D * E - B * F) / G;
                        double pY = (A * F - C * E) / G;

                        // r^2 = (a.X - pX) ^ 2.0 + (a.Y - pY) ^ 2.0
                        double radiusSqd = Math.Pow((a.X - pX), 2.0) + Math.Pow((a.Y - pY), 2.0);
                        double radius = Math.Sqrt(radiusSqd);

                        Point3d p3d_center = new Point3d(pX, pY, 0.0);
                        circleSurf = new Circle(p3d_center, new Vector3d(0.0, 0.0, 1.0), radius);
                    }
                    if (dbMpoly == null)
                    {
                        dbMpoly = new MPolygon();
                    }
                    dbMpoly.AppendLoopFromBoundary(circleSurf, false, 0.005);
                    dbMpoly.BalanceTree();
                    circleSurf.Dispose();
                    circleSurf = null;
                }
                //
                //Rectangle
                //
                if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle ||
                    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle)
                {
                    Polyline plineRect = new Polyline();
                    Point2d sw2d = new Point2d(ords[0], ords[1]);
                    Point2d se2d = new Point2d(ords[2 + IncrementFor3d], ords[1]);
                    Point2d ne2d = new Point2d(ords[2 + IncrementFor3d], ords[3 + IncrementFor3d]);
                    Point2d nw2d = new Point2d(ords[0], ords[3 + IncrementFor3d]);
                    Point2d closer2d = new Point2d(ords[0], ords[1]);
                    plineRect.AddVertexAt(plineRect.NumberOfVertices, sw2d, 0.0, 0.0, 0.0);
                    plineRect.AddVertexAt(plineRect.NumberOfVertices, se2d, 0.0, 0.0, 0.0);
                    plineRect.AddVertexAt(plineRect.NumberOfVertices, ne2d, 0.0, 0.0, 0.0);
                    plineRect.AddVertexAt(plineRect.NumberOfVertices, nw2d, 0.0, 0.0, 0.0);
                    plineRect.AddVertexAt(plineRect.NumberOfVertices, closer2d, 0.0, 0.0, 0.0);
                    plineRect.Closed = true;
                    if (drawable.Dimensionality == DrawAbleSdoGeometry.DefaultDimensionality3D)
                        plineRect.Elevation = ords[2];
                    if (dbMpoly == null)
                    {
                        dbMpoly = new MPolygon();
                    }
                    dbMpoly.AppendLoopFromBoundary(plineRect, false, 0.005);
                    dbMpoly.BalanceTree();
                    plineRect.Dispose();
                    plineRect = null;
                }
 
            }//Do the next subcomponent
            if (dbMpoly != null)
                return (object)dbMpoly;
            else if (dbPointList != null)
                return (object)dbPointList;
            else if (dbPoint != null)
                return (object)dbPoint;
            else if (plineLine != null)
                return (object)plineLine;
            else if (plineCurves != null)
                return (object)plineCurves;
            else if (plineCompound != null)
                return (object)plineCompound;
            else
                return null;

        }
    
        public static double GetBulge2d(CircularArc2d ca2d)
        {
            double theBulge = 0.0;
            if (ca2d.IsClockWise == true)
            {
                theBulge = -Math.Tan((ca2d.EndAngle - ca2d.StartAngle) / 4);
            }
            else
            {
                theBulge = Math.Tan((ca2d.EndAngle - ca2d.StartAngle) / 4);
            }
            return theBulge;
        }

    }//eoc DrawAbleDwg
}//eons

(VI) New SDO_GEOMETRY <-> Autodesk Map3d 2010

Author: Jonio, Dennis

The next on the list ...

Given some “DrawAble(s)” compose a NetSdoGeometry.sdogeometry.
The method signature:
public static sdogeometry SdoGeometryFromDrawAble(List _drawables, int _lrs, int _srid)
If you recall the DrawAble holds the dimensionality so the Measure and the SRID had to be injected somewhere.
Frankly the simplest of all the methods. Very straight forward implementaion.
Maybe somewhat unusual here is that I made this a static method within the static utility class.

Source code (C#):

+ expand sourceview plainprint?

1. public static sdogeometry SdoGeometryFromDrawAble(List<drawable> _drawables, int _lrs, int _srid)  
2. {  
3.  sdogeometry rtnval = null;  
4.  List<triints> TotElms = new List<triints>();  
5.  List<decimal> TotOrds = new List<decimal>();  
6.  int CURRENT_OFFSET = 1;  
7.  int CountOfItems = _drawables.Count;  
8.  int CountOfComponents = 0;  
9.   
10.  foreach (DrawAble drawable in _drawables)  
11.  {  
12.   CountOfComponents = drawable.SubComponents.Count;  
13.   foreach (DrawAbleSubComponent cmp in drawable.SubComponents)  
14.   {  
15.    TriInts nxt_elem = null;  
16.    //  
17.    //Compound components  
18.    //  
19.    if (cmp.Etype == DrawAbleSubComponentEType.CompoundLine ||  
20.     cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine ||  
21.     cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine)  
22.    {  
23.     TriInts frst_head = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), (cmp.Elem.Length / 3) - 1);  
24.     TotElms.Add(frst_head);  
25.     for (int _k = 3; _k < cmp.Elem.Length; )  
26.     {  
27.      TriInts nxt = new TriInts(CURRENT_OFFSET + cmp.Elem[_k + 0], cmp.Elem[_k + 1], cmp.Elem[_k + 2]);  
28.      TotElms.Add(nxt);  
29.      _k = _k + 3;  
30.     }  
31.     //Copy over the ordinates  
32.     for (int _i = 0; _i < cmp.Ords.Length; _i++)  
33.      TotOrds.Add(cmp.Ords[_i]);  
34.   
35.     //We get out of the major loop here ...   
36.     //so we MUST set the CURRENT_OFFSET to the end of the ordinates + start point.  
37.     CURRENT_OFFSET = CURRENT_OFFSET + cmp.Ords.Length;  
38.     continue;  
39.    }  
40.    //  
41.    //Point and PointCluster  
42.    //  
43.    if (cmp.Etype == DrawAbleSubComponentEType.Point)  
44.    {  
45.     nxt_elem = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), BasicINTERPRETATION(cmp.Etype));  
46.     TotElms.Add(nxt_elem);  
47.     //Copy over the ordinates  
48.     for (int _i = 0; _i < cmp.Ords.Length; _i++)  
49.      TotOrds.Add(cmp.Ords[_i]);  
50.     CURRENT_OFFSET = CURRENT_OFFSET + cmp.Ords.Length;  
51.     continue;  
52.    }  
53.    else if (cmp.Etype == DrawAbleSubComponentEType.PointCluster)  
54.    {  
55.     nxt_elem = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), cmp.Elem[2]);  
56.     TotElms.Add(nxt_elem);  
57.    }  
58.    //  
59.    //Lines  
60.    //  
61.    if (cmp.Etype == DrawAbleSubComponentEType.SimpleLine ||  
62.     cmp.Etype == DrawAbleSubComponentEType.SimpleLineAllCurves)  
63.    {  
64.     nxt_elem = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), BasicINTERPRETATION(cmp.Etype));  
65.     TotElms.Add(nxt_elem);  
66.    }  
67.    //  
68.    //Surface Stuff  
69.    //  
70.    if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves ||  
71.     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle ||  
72.     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine ||  
73.     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle ||  
74.     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves ||  
75.     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle ||  
76.     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine ||  
77.     cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle  
78.     )  
79.    {  
80.     nxt_elem = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), BasicINTERPRETATION(cmp.Etype));  
81.     TotElms.Add(nxt_elem);  
82.    }  
83.   
84.    //Copy over the ordinates and move the CURRENT OFFSET  
85.    for (int _i = 0; _i < cmp.Ords.Length; _i++)  
86.     TotOrds.Add(cmp.Ords[_i]);  
87.    CURRENT_OFFSET = TotOrds.Count + 1;  
88.   }  
89.  }  
90.  //  
91.  // Now build the geometry object  
92.  //  
93.  if (TotElms.Count > 0 && TotOrds.Count > 0)  
94.  {  
95.   DrawAble drawable = _drawables[0];  
96.   decimal[] tmp_elems = new decimal[TotElms.Count * 3];  
97.   for (int _e = 0; _e < TotElms.Count; _e++)  
98.   {  
99.    tmp_elems[_e * 3 + 0] = TotElms[_e].OFFSET;  
100.    tmp_elems[_e * 3 + 1] = TotElms[_e].ETYPE;  
101.    tmp_elems[_e * 3 + 2] = TotElms[_e].INTERP;  
102.   }  
103.   decimal[] tmp_ords = new decimal[TotOrds.Count];  
104.   tmp_ords = TotOrds.ToArray();  
105.   rtnval = new sdogeometry();  
106.   rtnval.LRS = _lrs;  
107.   rtnval.sdo_srid = _srid;  
108.   rtnval.Dimensionality = drawable.Dimensionality;  
109.   rtnval.ElemArray = tmp_elems;  
110.   rtnval.OrdinatesArray = tmp_ords;  
111.   rtnval.GeometryType = InferGeometryType(_drawables);  
112.   rtnval.PropertiesToGTYPE();  
113.  }  
114.  return rtnval;  
115. }  
116. </decimal></decimal></triints></triints></drawable>  

public static sdogeometry SdoGeometryFromDrawAble(List _drawables, int _lrs, int _srid)
{
 sdogeometry rtnval = null;
 List TotElms = new List();
 List TotOrds = new List();
 int CURRENT_OFFSET = 1;
 int CountOfItems = _drawables.Count;
 int CountOfComponents = 0;

 foreach (DrawAble drawable in _drawables)
 {
  CountOfComponents = drawable.SubComponents.Count;
  foreach (DrawAbleSubComponent cmp in drawable.SubComponents)
  {
   TriInts nxt_elem = null;
   //
   //Compound components
   //
   if (cmp.Etype == DrawAbleSubComponentEType.CompoundLine ||
    cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine ||
    cmp.Etype == DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine)
   {
    TriInts frst_head = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), (cmp.Elem.Length / 3) - 1);
    TotElms.Add(frst_head);
    for (int _k = 3; _k < cmp.Elem.Length; )
    {
     TriInts nxt = new TriInts(CURRENT_OFFSET + cmp.Elem[_k + 0], cmp.Elem[_k + 1], cmp.Elem[_k + 2]);
     TotElms.Add(nxt);
     _k = _k + 3;
    }
    //Copy over the ordinates
    for (int _i = 0; _i < cmp.Ords.Length; _i++)
     TotOrds.Add(cmp.Ords[_i]);

    //We get out of the major loop here ... 
    //so we MUST set the CURRENT_OFFSET to the end of the ordinates + start point.
    CURRENT_OFFSET = CURRENT_OFFSET + cmp.Ords.Length;
    continue;
   }
   //
   //Point and PointCluster
   //
   if (cmp.Etype == DrawAbleSubComponentEType.Point)
   {
    nxt_elem = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), BasicINTERPRETATION(cmp.Etype));
    TotElms.Add(nxt_elem);
    //Copy over the ordinates
    for (int _i = 0; _i < cmp.Ords.Length; _i++)
     TotOrds.Add(cmp.Ords[_i]);
    CURRENT_OFFSET = CURRENT_OFFSET + cmp.Ords.Length;
    continue;
   }
   else if (cmp.Etype == DrawAbleSubComponentEType.PointCluster)
   {
    nxt_elem = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), cmp.Elem[2]);
    TotElms.Add(nxt_elem);
   }
   //
   //Lines
   //
   if (cmp.Etype == DrawAbleSubComponentEType.SimpleLine ||
    cmp.Etype == DrawAbleSubComponentEType.SimpleLineAllCurves)
   {
    nxt_elem = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), BasicINTERPRETATION(cmp.Etype));
    TotElms.Add(nxt_elem);
   }
   //
   //Surface Stuff
   //
   if (cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves ||
    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle ||
    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine ||
    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle ||
    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves ||
    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle ||
    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine ||
    cmp.Etype == DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle
    )
   {
    nxt_elem = new TriInts(CURRENT_OFFSET, BasicETYPE(cmp.Etype), BasicINTERPRETATION(cmp.Etype));
    TotElms.Add(nxt_elem);
   }

   //Copy over the ordinates and move the CURRENT OFFSET
   for (int _i = 0; _i < cmp.Ords.Length; _i++)
    TotOrds.Add(cmp.Ords[_i]);
   CURRENT_OFFSET = TotOrds.Count + 1;
  }
 }
 //
 // Now build the geometry object
 //
 if (TotElms.Count > 0 && TotOrds.Count > 0)
 {
  DrawAble drawable = _drawables[0];
  decimal[] tmp_elems = new decimal[TotElms.Count * 3];
  for (int _e = 0; _e < TotElms.Count; _e++)
  {
   tmp_elems[_e * 3 + 0] = TotElms[_e].OFFSET;
   tmp_elems[_e * 3 + 1] = TotElms[_e].ETYPE;
   tmp_elems[_e * 3 + 2] = TotElms[_e].INTERP;
  }
  decimal[] tmp_ords = new decimal[TotOrds.Count];
  tmp_ords = TotOrds.ToArray();
  rtnval = new sdogeometry();
  rtnval.LRS = _lrs;
  rtnval.sdo_srid = _srid;
  rtnval.Dimensionality = drawable.Dimensionality;
  rtnval.ElemArray = tmp_elems;
  rtnval.OrdinatesArray = tmp_ords;
  rtnval.GeometryType = InferGeometryType(_drawables);
  rtnval.PropertiesToGTYPE();
 }
 return rtnval;
}

(V) New SDO_GEOMETRY <-> Autodesk Map3d 2010

Author: Jonio, Dennis

As I stated in the last post:

Given a NetSdoGeometry.sdogeometry decompose it into a “DrawAble(s)”.
As you would suspect this is mostly code. This is the actor that gets invoked every time DrawAbleSdoGeometry gets instantiated via DrawAbleSdoGeometry(sdogeometry aSDO_GEOMETRY) or the Geometry within an existing DrawAbleSdoGeometry gets changed.

The todo here is to breakdown and pair SDO_ELEM_INFO elements with SDO_ORDINATES elements. The end result will be at least one DrawAble(s).
Source code (C#):

+ expand sourceview plainprint?

1. private void DrawAblesFromGeometry()  
2. {  
3.  sdogeometry g = Geometry;  
4.  int[] elms = g.ElemArrayOfInts;  
5.  decimal[] ords = g.OrdinatesArray;  
6.  int dimensions = g.Dimensionality;  
7.  int OFFSET = 0, nxtOFFSET = 0;  
8.  int ETYPE = 0, nxtETYPE = 0;  
9.  int INTERP = 0, nxtINTERP = 0;  
10.  int ETYPE_plus_INTERP = 0;  
11.  //Just to make it easier to work with  
12.  List<triints> elmList = new List<triints>();  
13.  for (int _i = 0; _i < elms.Length; )  
14.  {  
15.   TriInts tmp_triplet = new TriInts(elms[_i], elms[_i + 1], elms[_i + 2]);  
16.   elmList.Add(tmp_triplet);  
17.   _i = _i + 3;  
18.  }  
19.  //Iterate through the triplets  
20.  for (int _j = 0; _j < elmList.Count; )  
21.  {  
22.   TriInts wrkrElm = elmList[_j];  
23.   OFFSET = wrkrElm.OFFSET;  
24.   ETYPE = wrkrElm.ETYPE;  
25.   INTERP = wrkrElm.INTERP;  
26.   ETYPE_plus_INTERP = ETYPE + INTERP;  
27.   //Look ahead is required for getting and setting offset into the ordinates array  
28.   if (_j < elmList.Count - 1)  
29.   { nxtOFFSET = elmList[_j + 1].OFFSET; nxtETYPE = elmList[_j + 1].ETYPE; nxtINTERP = elmList[_j + 1].INTERP; }  
30.   else  
31.   { nxtOFFSET = nxtETYPE = nxtINTERP = 0; }  
32.   int len_of_ords = 0;  
33.   if (nxtOFFSET > 0)  
34.   {  
35.    len_of_ords = nxtOFFSET - OFFSET;   
36.   }  
37.   else  
38.   {  
39.    len_of_ords = (ords.Length - OFFSET) + 1;  
40.   }  
41.   int len = 0;  
42.   //Based upon the ETYPE and the INTERPRETATION  
43.   switch (ETYPE)  
44.   {  
45.    case 1:  
46.     if (INTERP > 1)  
47.     {  
48.      DrawAble drawp = new DrawAble(DrawAbleType.Point, dimensions);  
49.      DrawAbleSubComponent drawpc = new DrawAbleSubComponent();  
50.      drawpc.Etype = DrawAbleSubComponentEType.PointCluster;  
51.      drawpc.Elem = new int[] { 0, 1, INTERP };  
52.      drawpc.Ords = new decimal[len];  
53.      Array.Copy(ords, OFFSET - 1, drawpc.Ords, 0, len_of_ords);  
54.      drawp.SubComponents.Add(drawpc);  
55.      this.Drawables.Add(drawp);  
56.     }  
57.     else if (INTERP == 1)  
58.     {  
59.      DrawAble drawp1 = new DrawAble(DrawAbleType.Point, dimensions);  
60.      DrawAbleSubComponent drawp1c = new DrawAbleSubComponent();  
61.      drawp1c.Etype = DrawAbleSubComponentEType.Point;  
62.      drawp1c.Ords = new decimal[len_of_ords];  
63.      Array.Copy(ords, OFFSET - 1, drawp1c.Ords, 0, len_of_ords);  
64.      drawp1.SubComponents.Add(drawp1c);  
65.      this.Drawables.Add(drawp1);  
66.     }  
67.     break;  
68.    case 2:  
69.     DrawAble drawl = new DrawAble(DrawAbleType.Line, dimensions);  
70.     DrawAbleSubComponent drawlc = new DrawAbleSubComponent();  
71.     if (ETYPE_plus_INTERP == (int)DrawAbleSubComponentEType.SimpleLine)  
72.      drawlc.Etype = DrawAbleSubComponentEType.SimpleLine;  
73.     else  
74.      drawlc.Etype = DrawAbleSubComponentEType.SimpleLineAllCurves;  
75.     drawlc.Ords = new decimal[len_of_ords];  
76.     Array.Copy(ords, OFFSET - 1, drawlc.Ords, 0, len_of_ords);  
77.     drawl.SubComponents.Add(drawlc);  
78.     this.Drawables.Add(drawl);  
79.     break;  
80.     case 4:  
81.     DrawAble drawcombo = new DrawAble(DrawAbleType.Line, dimensions);  
82.     DrawAbleSubComponent drawcomboc = new DrawAbleSubComponent();  
83.     drawcomboc.Etype = DrawAbleSubComponentEType.CompoundLine;  
84.     int number_of_subelements = INTERP;  
85.     int final_len_of_elms = (number_of_subelements * 3) + 3;  
86.     int first_OFFSET = OFFSET;  
87.     //The subelements PLUS the header  
88.     int[] redone_elms = new int[final_len_of_elms];  
89.     int redone_n = 0;  
90.     redone_elms[redone_n++] = OFFSET - first_OFFSET;  
91.     redone_elms[redone_n++] = ETYPE;  
92.     redone_elms[redone_n++] = INTERP;  
93.     _j = _j + 1;  
94.     for (int k = 1; k <= number_of_subelements; )  
95.     {  
96.      OFFSET = elmList[_j].OFFSET;  
97.      ETYPE = elmList[_j].ETYPE;  
98.      INTERP = elmList[_j].INTERP;  
99.   
100.      redone_elms[redone_n + 0] = OFFSET - first_OFFSET;  
101.      redone_elms[redone_n + 1] = ETYPE;  
102.      redone_elms[redone_n + 2] = INTERP;  
103.      redone_n = redone_n + 3;  
104.      k = k + 1;  
105.      _j = _j + 1;  
106.     }  
107.     // _j is now pointing past this "4" string and we MAY be looking at another drawable  
108.     // We find out by comparing the redone_elms count w/elmList count.  
109.     if ((number_of_subelements + 1) < elmList.Count)  
110.     {  
111.      len_of_ords = elmList[_j].OFFSET - first_OFFSET;  
112.      //We now decrement _j because we did not consume the entire thing.  
113.      _j = _j - 1;  
114.     }  
115.     else  
116.      len_of_ords = (ords.Length - first_OFFSET) + 1;  
117.   
118.     drawcomboc.Ords = new decimal[len_of_ords];  
119.     Array.Copy(ords, first_OFFSET - 1, drawcomboc.Ords, 0, len_of_ords);  
120.     //Copy the elms  
121.     drawcomboc.Elem = new int[(number_of_subelements * 3) + 3];  
122.     Array.Copy(redone_elms, 0, drawcomboc.Elem, 0, (number_of_subelements * 3) + 3);  
123.     //Add the component to the drawable  
124.     drawcombo.SubComponents.Add(drawcomboc);  
125.     //Add the drawable  
126.     this.Drawables.Add(drawcombo);  
127.     break;  
128.     case 1003:  
129.     DrawAble drawsurf1003 = new DrawAble(DrawAbleType.Surface, dimensions);  
130.     DrawAbleSubComponent drawsurfc1003 = new DrawAbleSubComponent();  
131.     switch (ETYPE_plus_INTERP)  
132.     {  
133.      case (int)DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine:  
134.       drawsurfc1003.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine;  
135.       break;  
136.      case (int)DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle:  
137.       drawsurfc1003.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle;  
138.       break;  
139.      case (int)DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves:  
140.       drawsurfc1003.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves;  
141.       break;  
142.      case (int)DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle:  
143.       drawsurfc1003.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle;  
144.       break;  
145.      default:  
146.       break;  
147.     }  
148.     if (nxtOFFSET == 0)  
149.      len = ords.Length - OFFSET + 1;  
150.     else  
151.      len = Math.Abs(nxtOFFSET - OFFSET);  
152.     drawsurfc1003.Ords = new decimal[len];  
153.     Array.Copy(ords, OFFSET - 1, drawsurfc1003.Ords, 0, len_of_ords);  
154.     drawsurf1003.SubComponents.Add(drawsurfc1003);  
155.     this.Drawables.Add(drawsurf1003);  
156.     break;  
157.     case 2003:  
158.     DrawAbleSubComponent drawsurfc2003 = new DrawAbleSubComponent();  
159.     switch (ETYPE_plus_INTERP)  
160.     {  
161.      case (int)DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine:  
162.       drawsurfc2003.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine;  
163.       break;  
164.      case (int)DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle:  
165.       drawsurfc2003.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle;  
166.       break;  
167.      case (int)DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves:  
168.       drawsurfc2003.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves;  
169.       break;  
170.      case (int)DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle:  
171.       drawsurfc2003.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle;  
172.       break;  
173.      default:  
174.       break;  
175.     }  
176.     if (nxtOFFSET == 0)  
177.      len = ords.Length - OFFSET + 1;  
178.     else  
179.      len = Math.Abs(nxtOFFSET - OFFSET);  
180.     drawsurfc2003.Ords = new decimal[len];  
181.     Array.Copy(ords, OFFSET - 1, drawsurfc2003.Ords, 0, len_of_ords);  
182.     bool hasHome = false;  
183.     for (int _i = this.Drawables.Count - 1; _i >= 0; _i--)  
184.     {  
185.      if (Drawables[_i].DrawEtype == DrawAbleType.Surface)  
186.      {  
187.       Drawables[_i].SubComponents.Add(drawsurfc2003);  
188.       hasHome = true;  
189.       break;  
190.      }  
191.     }  
192.     if (hasHome == false)  
193.      OrphanComponents.Add(drawsurfc2003);  
194.     break;  
195.     case 1005:  
196.     case 2005:  
197.     DrawAble drawsurfX005 = new DrawAble(DrawAbleType.Surface, dimensions);                          
198.     DrawAbleSubComponent drawsurfcX005 = new DrawAbleSubComponent();  
199.     if (ETYPE == 1005)  
200.      drawsurfcX005.Etype = DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine;  
201.     else  
202.      drawsurfcX005.Etype = DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine;  
203.     number_of_subelements = INTERP;  
204.     final_len_of_elms = (number_of_subelements * 3) + 3;  
205.     first_OFFSET = OFFSET;  
206.     //The subelements PLUS the header  
207.     redone_elms = new int[final_len_of_elms];  
208.     redone_n = 0;  
209.     redone_elms[redone_n++] = OFFSET - first_OFFSET;  
210.     redone_elms[redone_n++] = ETYPE;  
211.     redone_elms[redone_n++] = INTERP;  
212.     _j = _j + 1;  
213.     for (int k = 1; k <= number_of_subelements; )  
214.     {  
215.      OFFSET = elmList[_j].OFFSET;  
216.      ETYPE = elmList[_j].ETYPE;  
217.      INTERP = elmList[_j].INTERP;  
218.   
219.      redone_elms[redone_n + 0] = OFFSET - first_OFFSET;  
220.      redone_elms[redone_n + 1] = ETYPE;  
221.      redone_elms[redone_n + 2] = INTERP;  
222.      redone_n = redone_n + 3;  
223.      k = k + 1;  
224.      _j = _j + 1;  
225.     }  
226.     //We must remember to decrement _j because we may not have consumed the entire thing.  
227.     if ((number_of_subelements + 1) < elmList.Count)  
228.     {  
229.      len_of_ords = elmList[_j].OFFSET - first_OFFSET;  
230.     }  
231.     else  
232.      len_of_ords = (ords.Length - first_OFFSET) + 1;  
233.   
234.     drawsurfcX005.Ords = new decimal[len_of_ords];  
235.     Array.Copy(ords, first_OFFSET - 1, drawsurfcX005.Ords, 0, len_of_ords);  
236.     //Copy the elms  
237.     drawsurfcX005.Elem = new int[(number_of_subelements * 3) + 3];  
238.     Array.Copy(redone_elms, 0, drawsurfcX005.Elem, 0, (number_of_subelements * 3) + 3);  
239.     //Add the drawable if it is a 1005  
240.     if (drawsurfcX005.Etype == DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine)  
241.     {  
242.      //Add the component to the drawable  
243.      drawsurfX005.SubComponents.Add(drawsurfcX005);  
244.      this.Drawables.Add(drawsurfX005);  
245.     }  
246.     else  
247.     {  
248.      // This is a 2005 and it needs the "nearest" outer ring to live within  
249.      hasHome = false;  
250.      for (int _i = this.Drawables.Count - 1; _i >= 0; _i--)  
251.      {  
252.       if (Drawables[_i].DrawEtype == DrawAbleType.Surface)  
253.       {  
254.        Drawables[_i].SubComponents.Add(drawsurfcX005);  
255.        hasHome = true;  
256.        break;  
257.       }  
258.      }  
259.      if (hasHome == false)  
260.       OrphanComponents.Add(drawsurfcX005);  
261.     }  
262.     //We moved _j ahead ONE(1) to far ... in persuit of the nxtOFFSET.  
263.     //We must decrement it so we land back at real next "header" triplet  
264.     _j = _j - 1;  
265.     break;  
266.    default:  
267.     break;  
268.   }  
269.   _j = _j + 1;  
270.  }// main for loop  
271. }  
272. </triints></triints>  

private void DrawAblesFromGeometry()
{
 sdogeometry g = Geometry;
 int[] elms = g.ElemArrayOfInts;
 decimal[] ords = g.OrdinatesArray;
 int dimensions = g.Dimensionality;
 int OFFSET = 0, nxtOFFSET = 0;
 int ETYPE = 0, nxtETYPE = 0;
 int INTERP = 0, nxtINTERP = 0;
 int ETYPE_plus_INTERP = 0;
 //Just to make it easier to work with
 List elmList = new List();
 for (int _i = 0; _i < elms.Length; )
 {
  TriInts tmp_triplet = new TriInts(elms[_i], elms[_i + 1], elms[_i + 2]);
  elmList.Add(tmp_triplet);
  _i = _i + 3;
 }
 //Iterate through the triplets
 for (int _j = 0; _j < elmList.Count; )
 {
  TriInts wrkrElm = elmList[_j];
  OFFSET = wrkrElm.OFFSET;
  ETYPE = wrkrElm.ETYPE;
  INTERP = wrkrElm.INTERP;
  ETYPE_plus_INTERP = ETYPE + INTERP;
  //Look ahead is required for getting and setting offset into the ordinates array
  if (_j < elmList.Count - 1)
  { nxtOFFSET = elmList[_j + 1].OFFSET; nxtETYPE = elmList[_j + 1].ETYPE; nxtINTERP = elmList[_j + 1].INTERP; }
  else
  { nxtOFFSET = nxtETYPE = nxtINTERP = 0; }
  int len_of_ords = 0;
  if (nxtOFFSET > 0)
  {
   len_of_ords = nxtOFFSET - OFFSET; 
  }
  else
  {
   len_of_ords = (ords.Length - OFFSET) + 1;
  }
  int len = 0;
  //Based upon the ETYPE and the INTERPRETATION
  switch (ETYPE)
  {
   case 1:
    if (INTERP > 1)
    {
     DrawAble drawp = new DrawAble(DrawAbleType.Point, dimensions);
     DrawAbleSubComponent drawpc = new DrawAbleSubComponent();
     drawpc.Etype = DrawAbleSubComponentEType.PointCluster;
     drawpc.Elem = new int[] { 0, 1, INTERP };
     drawpc.Ords = new decimal[len];
     Array.Copy(ords, OFFSET - 1, drawpc.Ords, 0, len_of_ords);
     drawp.SubComponents.Add(drawpc);
     this.Drawables.Add(drawp);
    }
    else if (INTERP == 1)
    {
     DrawAble drawp1 = new DrawAble(DrawAbleType.Point, dimensions);
     DrawAbleSubComponent drawp1c = new DrawAbleSubComponent();
     drawp1c.Etype = DrawAbleSubComponentEType.Point;
     drawp1c.Ords = new decimal[len_of_ords];
     Array.Copy(ords, OFFSET - 1, drawp1c.Ords, 0, len_of_ords);
     drawp1.SubComponents.Add(drawp1c);
     this.Drawables.Add(drawp1);
    }
    break;
   case 2:
    DrawAble drawl = new DrawAble(DrawAbleType.Line, dimensions);
    DrawAbleSubComponent drawlc = new DrawAbleSubComponent();
    if (ETYPE_plus_INTERP == (int)DrawAbleSubComponentEType.SimpleLine)
     drawlc.Etype = DrawAbleSubComponentEType.SimpleLine;
    else
     drawlc.Etype = DrawAbleSubComponentEType.SimpleLineAllCurves;
    drawlc.Ords = new decimal[len_of_ords];
    Array.Copy(ords, OFFSET - 1, drawlc.Ords, 0, len_of_ords);
    drawl.SubComponents.Add(drawlc);
    this.Drawables.Add(drawl);
    break;
    case 4:
    DrawAble drawcombo = new DrawAble(DrawAbleType.Line, dimensions);
    DrawAbleSubComponent drawcomboc = new DrawAbleSubComponent();
    drawcomboc.Etype = DrawAbleSubComponentEType.CompoundLine;
    int number_of_subelements = INTERP;
    int final_len_of_elms = (number_of_subelements * 3) + 3;
    int first_OFFSET = OFFSET;
    //The subelements PLUS the header
    int[] redone_elms = new int[final_len_of_elms];
    int redone_n = 0;
    redone_elms[redone_n++] = OFFSET - first_OFFSET;
    redone_elms[redone_n++] = ETYPE;
    redone_elms[redone_n++] = INTERP;
    _j = _j + 1;
    for (int k = 1; k <= number_of_subelements; )
    {
     OFFSET = elmList[_j].OFFSET;
     ETYPE = elmList[_j].ETYPE;
     INTERP = elmList[_j].INTERP;

     redone_elms[redone_n + 0] = OFFSET - first_OFFSET;
     redone_elms[redone_n + 1] = ETYPE;
     redone_elms[redone_n + 2] = INTERP;
     redone_n = redone_n + 3;
     k = k + 1;
     _j = _j + 1;
    }
    // _j is now pointing past this "4" string and we MAY be looking at another drawable
    // We find out by comparing the redone_elms count w/elmList count.
    if ((number_of_subelements + 1) < elmList.Count)
    {
     len_of_ords = elmList[_j].OFFSET - first_OFFSET;
     //We now decrement _j because we did not consume the entire thing.
     _j = _j - 1;
    }
    else
     len_of_ords = (ords.Length - first_OFFSET) + 1;

    drawcomboc.Ords = new decimal[len_of_ords];
    Array.Copy(ords, first_OFFSET - 1, drawcomboc.Ords, 0, len_of_ords);
    //Copy the elms
    drawcomboc.Elem = new int[(number_of_subelements * 3) + 3];
    Array.Copy(redone_elms, 0, drawcomboc.Elem, 0, (number_of_subelements * 3) + 3);
    //Add the component to the drawable
    drawcombo.SubComponents.Add(drawcomboc);
    //Add the drawable
    this.Drawables.Add(drawcombo);
    break;
    case 1003:
    DrawAble drawsurf1003 = new DrawAble(DrawAbleType.Surface, dimensions);
    DrawAbleSubComponent drawsurfc1003 = new DrawAbleSubComponent();
    switch (ETYPE_plus_INTERP)
    {
     case (int)DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine:
      drawsurfc1003.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine;
      break;
     case (int)DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle:
      drawsurfc1003.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle;
      break;
     case (int)DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves:
      drawsurfc1003.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves;
      break;
     case (int)DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle:
      drawsurfc1003.Etype = DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle;
      break;
     default:
      break;
    }
    if (nxtOFFSET == 0)
     len = ords.Length - OFFSET + 1;
    else
     len = Math.Abs(nxtOFFSET - OFFSET);
    drawsurfc1003.Ords = new decimal[len];
    Array.Copy(ords, OFFSET - 1, drawsurfc1003.Ords, 0, len_of_ords);
    drawsurf1003.SubComponents.Add(drawsurfc1003);
    this.Drawables.Add(drawsurf1003);
    break;
    case 2003:
    DrawAbleSubComponent drawsurfc2003 = new DrawAbleSubComponent();
    switch (ETYPE_plus_INTERP)
    {
     case (int)DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine:
      drawsurfc2003.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine;
      break;
     case (int)DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle:
      drawsurfc2003.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle;
      break;
     case (int)DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves:
      drawsurfc2003.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves;
      break;
     case (int)DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle:
      drawsurfc2003.Etype = DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle;
      break;
     default:
      break;
    }
    if (nxtOFFSET == 0)
     len = ords.Length - OFFSET + 1;
    else
     len = Math.Abs(nxtOFFSET - OFFSET);
    drawsurfc2003.Ords = new decimal[len];
    Array.Copy(ords, OFFSET - 1, drawsurfc2003.Ords, 0, len_of_ords);
    bool hasHome = false;
    for (int _i = this.Drawables.Count - 1; _i >= 0; _i--)
    {
     if (Drawables[_i].DrawEtype == DrawAbleType.Surface)
     {
      Drawables[_i].SubComponents.Add(drawsurfc2003);
      hasHome = true;
      break;
     }
    }
    if (hasHome == false)
     OrphanComponents.Add(drawsurfc2003);
    break;
    case 1005:
    case 2005:
    DrawAble drawsurfX005 = new DrawAble(DrawAbleType.Surface, dimensions);                        
    DrawAbleSubComponent drawsurfcX005 = new DrawAbleSubComponent();
    if (ETYPE == 1005)
     drawsurfcX005.Etype = DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine;
    else
     drawsurfcX005.Etype = DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine;
    number_of_subelements = INTERP;
    final_len_of_elms = (number_of_subelements * 3) + 3;
    first_OFFSET = OFFSET;
    //The subelements PLUS the header
    redone_elms = new int[final_len_of_elms];
    redone_n = 0;
    redone_elms[redone_n++] = OFFSET - first_OFFSET;
    redone_elms[redone_n++] = ETYPE;
    redone_elms[redone_n++] = INTERP;
    _j = _j + 1;
    for (int k = 1; k <= number_of_subelements; )
    {
     OFFSET = elmList[_j].OFFSET;
     ETYPE = elmList[_j].ETYPE;
     INTERP = elmList[_j].INTERP;

     redone_elms[redone_n + 0] = OFFSET - first_OFFSET;
     redone_elms[redone_n + 1] = ETYPE;
     redone_elms[redone_n + 2] = INTERP;
     redone_n = redone_n + 3;
     k = k + 1;
     _j = _j + 1;
    }
    //We must remember to decrement _j because we may not have consumed the entire thing.
    if ((number_of_subelements + 1) < elmList.Count)
    {
     len_of_ords = elmList[_j].OFFSET - first_OFFSET;
    }
    else
     len_of_ords = (ords.Length - first_OFFSET) + 1;

    drawsurfcX005.Ords = new decimal[len_of_ords];
    Array.Copy(ords, first_OFFSET - 1, drawsurfcX005.Ords, 0, len_of_ords);
    //Copy the elms
    drawsurfcX005.Elem = new int[(number_of_subelements * 3) + 3];
    Array.Copy(redone_elms, 0, drawsurfcX005.Elem, 0, (number_of_subelements * 3) + 3);
    //Add the drawable if it is a 1005
    if (drawsurfcX005.Etype == DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine)
    {
     //Add the component to the drawable
     drawsurfX005.SubComponents.Add(drawsurfcX005);
     this.Drawables.Add(drawsurfX005);
    }
    else
    {
     // This is a 2005 and it needs the "nearest" outer ring to live within
     hasHome = false;
     for (int _i = this.Drawables.Count - 1; _i >= 0; _i--)
     {
      if (Drawables[_i].DrawEtype == DrawAbleType.Surface)
      {
       Drawables[_i].SubComponents.Add(drawsurfcX005);
       hasHome = true;
       break;
      }
     }
     if (hasHome == false)
      OrphanComponents.Add(drawsurfcX005);
    }
    //We moved _j ahead ONE(1) to far ... in persuit of the nxtOFFSET.
    //We must decrement it so we land back at real next "header" triplet
    _j = _j - 1;
    break;
   default:
    break;
  }
  _j = _j + 1;
 }// main for loop
}

(IV) New SDO_GEOMETRY <-> Autodesk Map3d 2010

Author: Jonio, Dennis

Before I begin to discuss additional detail I will briefly illustrate what it looks like to materialize an Autodesk/Map3d object from a NetSdoGeometry.sdogeometry with this approach. The other class DrawAbleDwg shown below has not been discussed at all to this point. This is in fact the simplest pattern that can be used when dealing with the MULTI type.
Source code (C#):

+ expand sourceview plainprint?

1. using MDADDrawAbles;  
2. using MDADDrawAbleDwg;  
3. using DDwg = MDADDrawAbleDwg.DrawAbleDwg;  
4.   
5. DrawAbleSdoGeometry D_sdo = new DrawAbleSdoGeometry(some_sdogeometry);  
6. foreach (DrawAble d in D_sdo.Drawables)  
7. {  
8.       object aObj = DDwg.DrawAbleDwgObj(d);  
9.   
10.       if (aObj is Autodesk.AutoCAD.DatabaseServices.MPolygon)  
11.       {  
12.           DDwg.AddMPolygon(aObj as MPolygon, 5, "MPolygon", "a polygon");  
13.       }  
14.       else if (aObj is Autodesk.AutoCAD.DatabaseServices.Polyline)  
15.           {  
16.              DDwg.AddPline(aObj as Polyline, 6, "Polyline", "a polyline");  
17.            }  
18.            else if (aObj is Autodesk.AutoCAD.DatabaseServices.DBPoint)  
19.                 {  
20.                   DDwg.AddPointd(aObj as DBPoint, 4, "Point", "a point");                               
21.                 }  
22. }  

using MDADDrawAbles;
using MDADDrawAbleDwg;
using DDwg = MDADDrawAbleDwg.DrawAbleDwg;

DrawAbleSdoGeometry D_sdo = new DrawAbleSdoGeometry(some_sdogeometry);
foreach (DrawAble d in D_sdo.Drawables)
{
      object aObj = DDwg.DrawAbleDwgObj(d);

      if (aObj is Autodesk.AutoCAD.DatabaseServices.MPolygon)
      {
          DDwg.AddMPolygon(aObj as MPolygon, 5, "MPolygon", "a polygon");
      }
      else if (aObj is Autodesk.AutoCAD.DatabaseServices.Polyline)
          {
             DDwg.AddPline(aObj as Polyline, 6, "Polyline", "a polyline");
           }
           else if (aObj is Autodesk.AutoCAD.DatabaseServices.DBPoint)
                {
                  DDwg.AddPointd(aObj as DBPoint, 4, "Point", "a point");                             
                }
}

The following illustrates just the opposite, a NetSdoGeometry.sdogeometry from multiple Autodesk/Map3d objects. The three(3) in this case will capture the Z axis. Actually I don't know what I am going to do with it but I have it if it is necessary.
Source code (C#):

+ expand sourceview plainprint?

1. DrawAble d3 = null;  
2. PromptSelectionOptions pso = new PromptSelectionOptions();  
3. pso.MessageForAdding = "\nEntities must be MPolygons, Polylines, Arc, Circles or Points.";  
4. pso.AllowDuplicates = false;  
5. pso.AllowSubSelections = false;  
6. pso.SingleOnly = false;  
7.   
8. PromptSelectionResult psr = ed.GetSelection(pso, MakeFilter());  
9. if (psr.Status == PromptStatus.OK)  
10. {  
11.  List<drawable> drawList = new List<drawable>();  
12.   
13.  using (Transaction tr = db.TransactionManager.StartTransaction())  
14.  {  
15.   foreach (SelectedObject seleobj in psr.Value)  
16.   {  
17.    Entity ent;  
18.    Entity entdb = (Entity)tr.GetObject(seleobj.ObjectId, OpenMode.ForRead);  
19.    //Other stuff  
20.    ent = entdb;  
21.    Polyline pl = ent as Polyline;  
22.    Polyline2d pl2d = ent as Polyline2d;  
23.    Polyline3d pl3d = ent as Polyline3d;  
24.    Arc anArc = ent as Arc;  
25.    DBPoint dbPoint = ent as DBPoint;  
26.    MPolygon mpoly = ent as MPolygon;  
27.    Line line = ent as Line;  
28.    Circle circ = ent as Circle;  
29.    if (line == null && pl == null && pl2d == null && pl3d == null && anArc == null  
30.     && dbPoint == null && mpoly == null && circ == null)  
31.    {  
32.    }  
33.    else  
34.    {  
35.   
36.     if (pl != null)  
37.     {  
38.      d3 = DDwg.LineCurveDrawAbleFromPolyline(pl, null, null, 3);  
39.     }  
40.     if (pl2d != null)  
41.     {  
42.      d3 = DDwg.LineCurveDrawAbleFromPolyline(null, pl2d, null, 3);  
43.     }  
44.     if (pl3d != null)  
45.     {  
46.      d3 = DDwg.LineCurveDrawAbleFromPolyline(null, null, pl3d, 3);  
47.     }  
48.     if (mpoly != null)  
49.     {  
50.      d3 = DDwg.PolygonDrawAbleFromMPolygon(mpoly, 3);  
51.     }  
52.     if (anArc != null)  
53.     {  
54.      d3 = DDwg.LineCurveDrawAbleFromArc(anArc, 3);  
55.     }  
56.     if (line != null)  
57.     {  
58.      d3 = DDwg.LineCurveDrawAbleFromLine(line, 3);  
59.     }  
60.     if (dbPoint != null)  
61.     {  
62.      d3 = DDwg.PointDrawAbleFromPoint(dbPoint, 3);  
63.     }  
64.     if (circ != null)  
65.     {  
66.      d3 = DDwg.LineCurveDrawAbleFromCircle(circ, 3);  
67.     }  
68.   
69.    }  
70.    drawList.Add(d3);  
71.   }//foreach object in the selection set  
72.  }//using transaction  
73.   
74.  sdogeometry geometry = DrawAbleSdoGeometryUtil.SdoGeometryFromDrawAble(drawList, 0, 2236);  
75.   
76. }//prompt stat OK   
77. </drawable></drawable>  

DrawAble d3 = null;
PromptSelectionOptions pso = new PromptSelectionOptions();
pso.MessageForAdding = "\nEntities must be MPolygons, Polylines, Arc, Circles or Points.";
pso.AllowDuplicates = false;
pso.AllowSubSelections = false;
pso.SingleOnly = false;

PromptSelectionResult psr = ed.GetSelection(pso, MakeFilter());
if (psr.Status == PromptStatus.OK)
{
 List drawList = new List();

 using (Transaction tr = db.TransactionManager.StartTransaction())
 {
  foreach (SelectedObject seleobj in psr.Value)
  {
   Entity ent;
   Entity entdb = (Entity)tr.GetObject(seleobj.ObjectId, OpenMode.ForRead);
   //Other stuff
   ent = entdb;
   Polyline pl = ent as Polyline;
   Polyline2d pl2d = ent as Polyline2d;
   Polyline3d pl3d = ent as Polyline3d;
   Arc anArc = ent as Arc;
   DBPoint dbPoint = ent as DBPoint;
   MPolygon mpoly = ent as MPolygon;
   Line line = ent as Line;
   Circle circ = ent as Circle;
   if (line == null && pl == null && pl2d == null && pl3d == null && anArc == null
    && dbPoint == null && mpoly == null && circ == null)
   {
   }
   else
   {

    if (pl != null)
    {
     d3 = DDwg.LineCurveDrawAbleFromPolyline(pl, null, null, 3);
    }
    if (pl2d != null)
    {
     d3 = DDwg.LineCurveDrawAbleFromPolyline(null, pl2d, null, 3);
    }
    if (pl3d != null)
    {
     d3 = DDwg.LineCurveDrawAbleFromPolyline(null, null, pl3d, 3);
    }
    if (mpoly != null)
    {
     d3 = DDwg.PolygonDrawAbleFromMPolygon(mpoly, 3);
    }
    if (anArc != null)
    {
     d3 = DDwg.LineCurveDrawAbleFromArc(anArc, 3);
    }
    if (line != null)
    {
     d3 = DDwg.LineCurveDrawAbleFromLine(line, 3);
    }
    if (dbPoint != null)
    {
     d3 = DDwg.PointDrawAbleFromPoint(dbPoint, 3);
    }
    if (circ != null)
    {
     d3 = DDwg.LineCurveDrawAbleFromCircle(circ, 3);
    }

   }
   drawList.Add(d3);
  }//foreach object in the selection set
 }//using transaction

 sdogeometry geometry = DrawAbleSdoGeometryUtil.SdoGeometryFromDrawAble(drawList, 0, 2236);

}//prompt stat OK 

DrawAbleSdoGeometryUtil.SdoGeometryFromDrawAble(drawList, 0, 2236); Passing in the DrawAble, the LRS, and the SRID produces a sdogeometry!

Here is the list of things that remain to be shown:

Given a NetSdoGeometry.sdogeometry decompose it into a “DrawAble(s)”.

Given some “DrawAble(s)” compose a NetSdoGeometry.sdogeometry.

Given one or more Autodesk/Map3d objects decompose it(them) into “Drawable(s)”.

Given a “DrawAble” compose a Autodesk/Map3d object.
To be continued ...