Topology Framework

Autodesk Map3d 2010 with WCF (III)

2010-02-03T14:46:00.004+01:00

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#):



     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)

2010-02-01T20:38:00.008+01:00

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#):


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#):


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)

2010-02-01T15:18:00.010+01:00

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#):


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

2009-11-19T17:10:00.004+01:00

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#):


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

2009-11-17T12:30:00.003+01:00

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#):


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

2009-11-15T21:07:00.004+01:00

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#):


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

2009-11-13T21:18:00.007+01:00

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#):


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#):


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 ...

(III) New SDO_GEOMETRY <-> Autodesk Map3d 2010

2009-11-12T16:33:00.002+01:00

Author: Jonio, Dennis

Before I forget I did put together a simple class to aid in manipulating the three(3) element array structures that comprise SDO_ELEM_INFO_ARRAY.
Source code (C#):


    [Serializable]
    public class TriInts
    {
        public int OFFSET
        { set { TriInt[0] = value; } get { return TriInt[0]; } }
        public int ETYPE
        { set { TriInt[1] = value; } get { return TriInt[1]; } }
        public int INTERP
        { set { TriInt[2] = value; } get { return TriInt[2]; } }
        private int[] TriInt;

        public TriInts()
        {
            TriInt = new int[] { 0, 0, 0 };
        }
        public TriInts(int o, int e, int i)
        {
            TriInt = new int[3];
            TriInt[0] = o;
            TriInt[1] = e;
            TriInt[2] = i;
        }
        public TriInts(TriInts triint)
        {
            TriInt = new int[3];
            TriInt[0] = triint.OFFSET;
            TriInt[1] = triint.ETYPE;
            TriInt[2] = triint.INTERP;
        }
        public int[] ToArray()
        {
            return new int[] { OFFSET, ETYPE, INTERP };
        }
    }//eoc TriInts

So now we get to the primary actor DrawAbleSdoGeometry. The container class for the NetSdoGeometry.sdogeometry type and the supporting cast of players to break sdogeometry down into DrawAble(s) and build a sdogeometry from DrawAble(s). Again the paradigm is all about this intermediate drawable construct so Autodesk/Map3d doesn’t come into play here. That is all handled in a separate class!
Source code (C#):


    [Serializable]
    public class DrawAbleSdoGeometry
    {
        private sdogeometry m_Geometry;
        public const decimal DefaultSRID2236 = 2236;
        public const int DefaultLRS0 = 0;
        public const int DefaultDimensionality2D = 2;
        public const int DefaultDimensionality3D = 3;
        public decimal SRID = DefaultSRID2236;
        public int LRS = DefaultLRS0;
        public int Dimensionality = DefaultDimensionality2D;
        public List Drawables = new List();
        public List OrphanComponents = new List();        
        // Default ctor - nothing to do
        public DrawAbleSdoGeometry() { }
        // ctor from an existing SDO_GEOMETRY object
        public DrawAbleSdoGeometry(sdogeometry aGeometry)
        {
            this.Geometry = aGeometry;
        }
}//eoc DrawAbleSdoGeometry

I set a default Dimensionality, LRS and SRID but have left them totally accessible. I am not one to hide things away in some private corner somewhere unless it just is nonsensical to do otherwise. Like DrawAblesFromGeometry(), the player that decomposes a sdogeometry/SDO_GEOMETRY object into DrawAble(s). It only made sense to me to invoke this directly from the “setter” for the class’ Geometry object.
Note also that within the “setter” I deal with that Optimized Point issue.
Source code (C#):


       public sdogeometry Geometry
        {
            get { return this.m_Geometry; }

            set
            {
                m_Geometry = value;
                try
                {
                    m_Geometry.PropertiesFromGTYPE();
                    Dimensionality = m_Geometry.Dimensionality;

                    if (m_Geometry.sdo_point != null)
                    {
                        m_Geometry.ElemArray = new decimal[] { 1, 1, 1 };
                        if (m_Geometry.Dimensionality == 2)
                            m_Geometry.OrdinatesArray = new decimal[] { (decimal)m_Geometry.sdo_point.X, (decimal)m_Geometry.sdo_point.Y };
                        else if (m_Geometry.Dimensionality == 3)
                            m_Geometry.OrdinatesArray = new decimal[] { (decimal)m_Geometry.sdo_point.X, (decimal)m_Geometry.sdo_point.Y, (decimal)m_Geometry.sdo_point.Z };
                        m_Geometry.sdo_point = null;
                    }
                    if (m_Geometry.ElemArray != null && m_Geometry.OrdinatesArray != null)
                        DrawAblesFromGeometry();
                }
                catch (System.Exception) {/*Just eat it all*/}
            }
        }

As regards catching and eating any errors at this level I am ambivilant. I really do assume VALID geometry coming in because I produce VALID geometry on the other end. You may see it differently.

To be continued …

(II) New SDO_GEOMETRY <-> Autodesk Map3d 2010

2009-11-12T12:27:00.007+01:00

Author: Jonio, Dennis

The DrawAbleType enums were easy. I just had to give them values that could be distinguised via “OR”ing them together.

Point = 1,

Line = 2,

Surface = 4

Source code (C#):


       public static int InferGeometryType(List _drawables)
        {
            int rtnval = 0;
            if (_drawables.Count == 1)
            {
                switch (_drawables[0].DrawEtype)
                {
                    case DrawAbleType.Point:
                        rtnval = 1;
                        break;
                    case DrawAbleType.Line:
                        rtnval = 2;
                        break;
                    case DrawAbleType.Surface:
                        rtnval = 3;
                        break;
                }
            }
            else
            {
                int ttype = 0;
                foreach (DrawAble d in _drawables)
                    ttype = ttype | (int)d.DrawEtype;

                switch (ttype)
                {
                    case 1:
                        rtnval = 5; //MultiPoint
                        break;
                    case 2:
                        rtnval = 6; //MultiLine
                        break;
                    case 4:
                        rtnval = 7; //MultiPolygon
                        break;
                    default:
                        rtnval = 4; //Collection
                        break;
                }
            }
            return rtnval;
        }

I really wrestled with these DrawAbleSubComponentEType enums. I tried to be really clever with these values and somehow take advantage of the relationship between ETYPE and INTERPRETATION. Tried is the operative word.

Point = 1, //1

PointCluster = 10, //1 + n

PointOriented = 19, //Not supported OrientedPoint

SimpleLine = 3, //2 + 1

SimpleLineAllCurves = 4, //2 + 2

CompoundLine = 40, //4 + n

SimpleSurfaceOuterRingLine = 1004, //1003 + 1

SimpleSurfaceOuterRingAllCurves = 1005, //1003 + 2

SimpleSurfaceOuterRingRectangle = 1006, //1003 + 3

SimpleSurfaceOuterRingCircle = 1007, //1003 + 4

SimpleSurfaceInnerRingLine = 2004, //2003 + 1

SimpleSurfaceInnerRingAllCurves = 2005, //2003 + 2

SimpleSurfaceInnerRingRectangle = 2006, //2003 + 3

SimpleSurfaceInnerRingCircle = 2007, //2003 + 4

CompoundSurfaceOuterRingLine = 10050, //1005 + n

CompoundSurfaceInnerRingLine = 20050 //2005 + n
The specification has to many exceptions for this to work but at least I have my unique values.

I do wonder alot as to why Oracle set up the unique combinations for Circle, Rectangle and instances of all Curves. I did read the spec on “Oriented Point” and just arbitrarily decided NOT to support it. I will never use it and I guess I am the boss. So if you need that you will have to do it yourself. It should be a straight forward job for someone with the motivation.

When it gets time to resolve these into the “real” ETYPE and INTERPRETATION values I just set up a couple static methods in a static utility class.
Source code (C#):


        public static int BasicETYPE(DrawAbleSubComponentEType t)
        {
            int rtnval = 0;
            switch (t)
            {
                case DrawAbleSubComponentEType.Point:
                case DrawAbleSubComponentEType.PointCluster:
                case DrawAbleSubComponentEType.PointOriented:
                    rtnval = 1;
                    break;
                case DrawAbleSubComponentEType.SimpleLine:
                case DrawAbleSubComponentEType.SimpleLineAllCurves:
                    rtnval = 2;
                    break;
                case DrawAbleSubComponentEType.CompoundLine:
                    rtnval = 4;
                    break;
                case DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine:
                case DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves:
                case DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle:
                case DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle:
                    rtnval = 1003;
                    break;
                case DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine:
                case DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves:
                case DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle:
                case DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle:
                    rtnval = 2003;
                    break;
                case DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine:
                    rtnval = 1005;
                    break;
                case DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine:
                    rtnval = 2005;
                    break;
                default:
                    break;
            }
            return rtnval;
        }
       public static int BasicINTERPRETATION(DrawAbleSubComponentEType t)
        {
            int rtnval = 0;
            switch (t)
            {
                case DrawAbleSubComponentEType.Point:
                case DrawAbleSubComponentEType.SimpleLine:
                case DrawAbleSubComponentEType.SimpleSurfaceInnerRingLine:
                case DrawAbleSubComponentEType.SimpleSurfaceOuterRingLine:
                    rtnval = 1;
                    break;
                case DrawAbleSubComponentEType.SimpleSurfaceInnerRingAllCurves:
                case DrawAbleSubComponentEType.SimpleSurfaceOuterRingAllCurves:
                case DrawAbleSubComponentEType.SimpleLineAllCurves:
                    rtnval = 2;
                    break;
                case DrawAbleSubComponentEType.SimpleSurfaceOuterRingRectangle:
                case DrawAbleSubComponentEType.SimpleSurfaceInnerRingRectangle:
                    rtnval = 3;
                    break;
                case DrawAbleSubComponentEType.SimpleSurfaceInnerRingCircle:
                case DrawAbleSubComponentEType.SimpleSurfaceOuterRingCircle:
                    rtnval = 4;
                    break;
                case DrawAbleSubComponentEType.PointCluster:
                case DrawAbleSubComponentEType.CompoundLine:
                case DrawAbleSubComponentEType.CompoundSurfaceOuterRingLine:
                case DrawAbleSubComponentEType.CompoundSurfaceInnerRingLine:
                    rtnval = 0;
                    break;
                case DrawAbleSubComponentEType.PointOriented:
                    rtnval = 9;
                    break;
                default:
                    break;
            }
            return rtnval;
        }

To be continued ...

(I) New SDO_GEOMETRY <-> Autodesk Map3d 2010

2009-11-09T13:19:00.010+01:00

Author: Jonio, Dennis

Howdy all.
Well, it has really been awhile since that last post. By the way, I have no idea what happened to Maksim Sestic. Anyone willing to let me know?

Anyway a lot has transpired over the months not the least of which is that some time ago I built a shiny new Autodesk 2010/Map3d <-> SDO_GEOMETRY translator.

The learning example I have posted here was/is OK and served its purpose. However, like most software it had to be fixed and/or enhanced (and in this case just thrown away!)
The new converter supports everything that is in keeping with the Oracle Locator’s - Right To Use license. Obviously then there is no 3D object support. Curves are still fully supported and now ALL of the MULT types are supported. I do include support for the Z axis in this generation. In order to support the MULTI types I forced myself into building some “intermediate” objects. This also lays some of the groundwork for a different geometry object generator in the future. No, we are not having any problems or issues with Autodesk but maybe something else will come along. My NetSdoGeometry.sdogeometry object had to be tweaked a little so that it fully supported the Z axis. Beyond that it is good to go.

Three(3) primary objectives drove this iteration of the translator.
I) I wished to support a Z axis value
II) I wished to support the Oracle MULTI types
III) A more flexible overall design in general.
I had to modify my sdogeometry AsText property/ToString method to support the Z axis. If you recall I go out of my way to NOT utilize the "optimized point". I am sure it is a fine thing. For me, logically and programmatically, it is more trouble than its worth. In my way of thinking there is nothing wrong with an SDO_ELEM_INFO_ARRAY(1,1,1) and it is somewhat more consistent with the rest of the standard. I do of course read them in but I never output a SDO_POINT.
Source code (C#):


   public string AsText
 {
  get
  {
   StringBuilder sb = new StringBuilder();
   sb.Append("MDSYS.SDO_GEOMETRY(");
   sb.Append((sdo_gtype != null) ? sdo_gtype.ToString() : "null");
   sb.Append(",");
   sb.Append((sdo_srid != null) ? sdo_srid.ToString() : "null");
   sb.Append(",");
   // begin point
   if (sdo_point != null)
   {
    sb.Append("MDSYS.SDO_POINT_TYPE(");
    string _tmp = string.Format("{0:0.0#####},{1:0.0#####}{2}{3:#.######}",
            sdo_point.X,
            sdo_point.Y,
            (sdo_point.Z == null) ? null : ",",
            sdo_point.Z);
    
    sb.Append(_tmp.Trim());
    sb.Append(")");
   }
   else
   {
    sb.Append("null");
   }
   sb.Append(",");
   // begin element array
   if (elemArray != null)
   {
    sb.Append("MDSYS.SDO_ELEM_INFO_ARRAY(");
    for (int i = 0; i < elemArray.Length; i++)
    {
     string _tmp = string.Format("{0}", elemArray[i]);
     sb.Append(_tmp);
     if (i < (elemArray.Length - 1))
      sb.Append(",");
    }
    sb.Append(")");
   }
   else
   {
    sb.Append("null");
   }
   sb.Append(",");
   // begin ordinates array
   if (ordinatesArray != null)
   {
    sb.Append("MDSYS.SDO_ORDINATE_ARRAY(");
    for (int i = 0; i < ordinatesArray.Length; i++)
    {
     string _tmp = string.Format("{0:0.0######}", ordinatesArray[i]);
     sb.Append(_tmp);
     if (i < (ordinatesArray.Length - 1))
      sb.Append(",");
    }
    sb.Append(")");
   }
   else
   {
    sb.Append("null");
   }
   sb.Append(")");
   return sb.ToString();
  }
 }
 public override string ToString()
 {
  return this.AsText;
 }

Here is the conceptual paradigm that I chose for this iteration:
An Autodesk drawable entity decomposes into one or more SDO_ELEM_INFO_ARRAY triplet(s) with corresponding ordinates. An Autodesk drawable entity may be composed of one or more SDO_ELEM_INFO_ARRAY triplet(s) with corresponding ordinates.
With this mental shift from my original tool which is based upon a one-to-one/entity-to-sdogeometry relationship things flowed pretty well. Frankly this was a necessary shift in thinking to support the MULTI types.
So a class "DrawAble" is composed of "DrawAbleSubComponent"(s) and DrawAbleSubComponents equate to SDO_ELEM_INFO_ARRAY triplet(s) and their corresponding ordinates.
Source code (C#):


    [Serializable]
    public class DrawAbleSubComponent
    {
        public int[] Elem;
        public decimal[] Ords;
        public DrawAbleSubComponentEType Etype;
    }//eoc DrawAbleSubComponent
 
    [Serializable]
    public class DrawAble
    {
        private DrawAbleType m_drawtype;
        public DrawAbleType DrawEtype 
        { get{return m_drawtype;} set { m_drawtype = value; }}
        
        private int m_dimensionality = 2;
        public int Dimensionality
        { get { return m_dimensionality; } set { m_dimensionality = value; } }

        public List SubComponents = new List();
        public DrawAble(DrawAbleType _type, int _dimensionality)
        {
            DrawEtype = _type;
            Dimensionality = _dimensionality;
        }
    }//eoc DrawAble

To be continued ...

SDO_GEOMETRY - FROM and TO Autodesk Map3d

2009-01-20T20:13:00.005+01:00

Author: Jonio, Dennis

This Visual Studio 2005 solution contains everything you need to PUT/GET 2d curve SDO_GEOMETRY from/to Autodesk Map3d. It is of course a named-pipe solution. I have tested this particular one briefly on both Map3d 2008 and Map3d 2009. No warranties about anything. I have not included my SDO_GEOMETRY Validation class and anything having to do with SDO_DIM_ARRAY. This is posted elsewhere.
What you will need: Visual Studio 2005, Map3d 2008/2009, ODP.NET 11g.
The last and most significant new code included here is the DwgReader and the DwgWriter classes. They are nothing more than convenience containers for the geometry conversion methods contained with these same named classes.
As I have learned the idiosyncrasies and subtleties of doing conversions from one geometry system to the other are immense. For example: Circles ... what about circles? Just pursue this one issue yourself and you should become somewhat befuddled at what approach to take.
I am aware that the conversion routine for inner and outer rings of polygons is somewhat flawed in that it does not handle ring direction properly in all cases. This has not been a big concern for me since every piece of production geometry I create gets passed through a "validator" and in the case of ring orientation SDO_MIGRATE.TO_CURRENT works fine for fix up. This was another of those lessons learned. You should always check the geometry you are going to convert. If you were not aware already, you can easily create polygon geometry in Map3d that nothing but Map3d will understand. It is what it is.

The NETLOADable dll is ADSKDATABRIDGE.dll and the commandline command is: DOPUTGET.

Startup “ClientBasicIO.exe” and your off and running.

I have included the file “AGEOM1.sds” with the project. This is a serialized .NET dataset with a few geometries. You can load it within clientbasicio.exe.

Enough … code speaks for itself …

You can download the solution here: http://tf-net.googlecode.com/files/aPub.zip

A Simple Named Pipes Solution for Autodesk Map3d

2008-11-15T18:05:00.005+01:00

Author: Jonio, Dennis

I have recently decided to put together a minimalist IPC namedpipes application. I just could not think of something simplier than what I have here. This is like using a 747 jetliner to commute cross town to work but it does illustrate the ease. It is a complete, zipped up, Visual Studio 2005 solution with the entire source that I have outlined in other posts. To reiterate I use Map3d 2008 and have not tested this against vanilla AutoCAD. You will have to tell me if it works or not. I have no dependences on Map3d that I can think of.

The NETLOADable dll is, you guessed it, IPCSimple.dll. Load it up and commandline: doit. The “DataBridge” form is minimized at startup.

Startup “ClientBasicIO.exe” it is pretty obvious what to do from this point.

Most of what is happening I consider pretty much to be “boilerplate”, again thanks to Ivan Latunov. My particular implementation of serializing/de-serializing the datasets can easily be changed to support whatever construction you like. Sending a text string for “SendStringToExecute” is really kind’a sort’a silly but, like I said, I could not think of anything simpler.

At this point it is up to your imaginations as to how this can work for you. …enjoy!

You can download the solution here: http://tf-net.googlecode.com/files/IPCSimple.zip

Org.OpenGIS.GeoAPI Revisited - Part I

2008-11-14T10:34:00.037+01:00

Author: Sestic, Maksim

I've been thinking of starting this article by lamenting on current state of the available managed OGC's GeoAPI interface implementations, but I won't :-) If you're reading this - you have probably already hit their limitations. I'm talking about GeoAPI interface ports here (a la GeoAPI.NET), not concrete implementations (i.e. NetTopologySuite, SharpMap or Proj.NET).

Not having common managed interface library makes things a lot harder for GIS developers. Present one(s) won't help you much either - most of them got way out of synch when compared to their Java-based raw model maintaned by OGC. In the meantime, Microsoft's .NET Framework itself evolved a lot, etc. To cut the long story short, my idea was to start managed GeoAPI interfaces from scratch, based on present GeoAPI 2.1.1 interfaces specification - but not by simply jumping into it...

Naming Conventions

Lets start with something "obvious" - naming conventions used in Java and .NET. For example: org.opengis.geometry namespace becomes Org.OpenGIS.Geometry namespace in .NET. Both camel-case and abbreviation rules apply, starting letter always capitalized.

When it comes to interface names, since it's mostly about them, each Java class pertaining to an interface gets an "I" prefix. For example: Precision interface becomes IPrecision in .NET.

Naming and Type Conventions

Java Get/Set functions become Properties. That is - ReadOnly properties for explicit getter functions, or WriteOnly properties for explicit setter functions. Also, get/set prefix gets stripped from resulting property name, always starting with a capital letter. For example:

Function getLength() As Double

becomes:

ReadOnly Property Length() As Double

Also:

Function getLength() As Double
Sub setLength(d As Double)

method pair becomes:

Property Length() As Double

So, when Java function becomes .NET property, and when it simply remains a method - beyond getter/setter rules stated above? It depends on overall method semantics; what it actually means to hosting class/object. For example:

Function setLength(d As Double)

when alone in a class, becomes:

WriteOnly Property Length() As Double

Because Length is a class property. But:

Function ToArray() As Double()

remains a function, since it's a method to hosting class. Sticking to described semantic rules, even parametrized functions become properties. For example:

Function getBuffer(d As Double) As IGeometry

becomes:

ReadOnly Property Buffer(ByVal d As Double) As IGeometry

since buffer is a parametrized geometric property (one of many, of course).

Type Conventions And Enumerators

Enumerated types seem rather confusing to present managed GeoAPI ports. In fact, they're simple enumerators. A good example for this is org.opengis.geometry.PrecisionType which derives from (extends) generic Java CodeList type. In .NET it becomes:

Public Enum PrecisionType

with it's members slightly changed when it comes to naming: DOUBLE becomes Double, FIXED becomes Fixed, etc. If we had a Java member named PIECEWISE_BEZIER, then it would become PiecewiseBezier in .NET. BTW, proposed notation is way closer to original ISO identifier naming rules anyways.

Type Conventions And Generics

This is the most challening part of it all. That's also why IKVM.NET won't help you much with GeoAPI in first place. Yes, it's about .NET generics and how do we use them in GeoAPI - keeping in mind future implementations. IMHO, it's very important to introduce strongly typed collections to managed GeoAPI interfaces. Alas, without knowing the nature of each interface it's close to impossible to introduce their generic counterparts properly. In other words - one needs to consult UML definition and think ahead of possible implications on implementers' side.

Ongoing Activities

You can check the current development status of managed GeoAPI library based on present GeoAPI 2.1.1 interfaces specification here: Managed OpenGIS GeoAPI Interfaces (look under SVN trunk).

Extending the IGeometryCollection type with methods provided on the HashSet(T) class

2008-11-04T21:51:00.036+01:00

Author: Baxevanis, Nikos

Overview

As of Kim Hamilton’s post, http://blogs.msdn.com/bclteam/archive/2006/11/09/introducing-hashset-t-kim-hamilton.aspx “HashSet determines equality according to the EqualityComparer you specify, or the default EqualityComparer for the type (if you didn’t specify)”.

The IGeometryCollection type implements the IComparable(T). Using extension methods we “add” methods from the HashSet(T) class so any type that implements the IGeometryCollection appears to have instance methods such as IntersectWith, UnionWith etc.

The IGeometryCollection type implements the IComparable(T).

A HashSet(T) operation modifies the set it’s called on and doesn’t create a new set. The extension methods provided with this article return an IGeometryCollection object rather than modifying the caller set.

Implementation

“Extension methods are defined as static methods but are called by using instance method syntax. Their first parameter specifies which type the method operates on, and the parameter is preceded by the this modifier. Extension methods are only in scope when you explicitly import the namespace into your source code with a using directive.” http://msdn.microsoft.com/en-us/library/bb359438.aspx


        public static Topology.Geometries.IGeometryCollection UnionWith(this Topology.Geometries.IGeometryCollection geomCol, Topology.Geometries.IGeometryCollection otherCol)
        {
            return Operation(geomCol, otherCol, OperationType.Union);
        }

        public static Topology.Geometries.IGeometryCollection IntersectWith(this Topology.Geometries.IGeometryCollection geomCol, Topology.Geometries.IGeometryCollection otherCol)
        {
            return Operation(geomCol, otherCol, OperationType.Intersection);
        }

        private static Topology.Geometries.IGeometryCollection Operation(Topology.Geometries.IGeometryCollection geomCol, Topology.Geometries.IGeometryCollection otherCol, OperationType typeOp)
        {
            HashSet geomSet =
               new HashSet();

            foreach (Topology.Geometries.IGeometry geom in geomCol)
                geomSet.Add(geom);

            HashSet otherSet =
                new HashSet();

            foreach (Topology.Geometries.IGeometry geom in otherCol)
                otherSet.Add(geom);

            switch (typeOp)
            {
                case OperationType.Intersection:
                    geomSet.IntersectWith(otherSet);
                    break;

                case OperationType.Union:
                    geomSet.UnionWith(otherSet);
                    break;

                case OperationType.Except:
                    geomSet.ExceptWith(otherSet);
                    break;

                case OperationType.SymmetricExcept:
                    geomSet.SymmetricExceptWith(otherSet);
                    break;

                default:
                    return Topology.Geometries.GeometryCollection.Empty;
            }

            Topology.Geometries.IGeometry[] array =
               new Topology.Geometries.IGeometry[geomSet.Count];

            geomSet.CopyTo(array);

            return new Topology.Geometries.GeometryFactory().CreateGeometryCollection(array);
        }

Using the extension methods in your code

You have to add a reference to Topology.Geometries.GeometryCollectionExtensions.dll
To use the HashSet(T) operations first bring them into scope with a using Topology.Geometries.GeometryCollectionExtensions directive.

Using the HashSet(T) operations

Available for download here: http://tf-net.googlecode.com/files/GeometryCollectionExtensions-Source.zip

Inter-Process Communication (IPC) with Autodesk Map3d

2008-10-28T13:17:00.032+01:00

Author: Jonio, Dennis

Prospective and Environment
Everything that follows was done on and with Windows XP SP2, Visual Studio 2005 Professional SP1, Oracle XE 10.2, Oracle ODP.NET 11g(2.111.6.20), Autodesk Map3d 2008 SP1, Autodesk ObjectARX 2008 and lots of reading and lots of research. Since I have not done it myself I cannot attest as to the viability of this solution in a vanilla AutoCAD 200x environment. I am however inclined to believe that it will work just fine. I make neither guarantees nor claims of fitness for any purpose. It is “as-is” so proceed at your own risk.

Overview
Simply stated, this was the problem, I wished to have a generic way in which to communicate with a DWG. All I wished to do was PUT an SDO_GEOMETRY and GET a selected entity back as an SDO_GEOMETRY. This seemed to me to be a not unreasonable request. Just think about this a second: AutoCAD as a COLUMN editor? I could build whatever user interface I wished, using whatever tools I wished. Include all the business logic needed and then just “plumb” this stand-alone application. I didn’t have to solve the world’s problems either. Points, lines and surfaces were all I was interested in. Well good luck! First off there was no .NET DWG to SDO_GEOMETRY translator that I could get my hands on. Second, this just is not how Autodesk has written their applications. Don’t misunderstand me here. This is not a flame against Autodesk. Their applications do what they were designed to do and do this very well. So this series is then about getting one of two major things accomplished: 1) A 2-dimensional, SDO_GEOMETRY translator that supported arcs and 2) A communications interface.

This is about the communications piece. In my mind this would be the most technically challenging and if I was going to fail it would be on this.

Of course the issue of multithreading arose numerous times but it always seemed, by its nature, to be somewhat limiting. Inter-process communication (IPC) was the answer but I found no ready made solution. I had to piece this together myself. I did a fair amount of investigating and found named pipes to be the most generic and robust approach to take.

This is not really a story about pipes but you must look at this article: “Inter-Process Communication in .NET Using Named Pipes” by Ivan Latunov.
link to article The author explains it all much better than I ever could and his implementation is the backbone of this implementation. By the way, I believe that Microsoft has now included Named Pipe support in the 3.5 .NET framework. Since MS pipes are a Client/Server architecture and I was totally intimidated by “overlapping” ,“bidirectional” and the other more complex implementations I decided to really simplify and incorporate, in each executable or dll, a pipe Server and a pipe Client. Thank you Ivan. The significant change that I incorporated was the use of Events on the Server side( the “owner” side if you will ). When you compare Ivan’s code to mine you will see some other minor changes. A simple piccy to illustrate the idea.

Since experience has taught me that the Autodesk API’s are not trivial especially when it comes to the MDI interface structure I really needed to isolate this application as much as possible. The solution was a simple data exchange mechanism, a data “bridge”, if you will. Let the bridge become the generic between the other executables! My NETLOADed module and the “bridge” will communicate with simple Events and Queue objects! The Autodesk API’s understands Forms, Forms are, by nature, multi-threaded! The bridge will then communicate to whatever is at the other end of the pipe. BINGO! We have it all!

Below is a clip where these ideas are put together. Very simple and straightforward but it should give you some "food for thought":

Full-size video clip is available for download at:

http://tf-net.googlecode.com/files/ipc_acad_sdo.rar

The Communications Data Definition

OK… so now we have settled on the communications “plumbing”, a full blown IO channel no less, what is it that we wish to communicate?
Well in reading Ivan’s work and the work of some others I became aware that pipes can move megabytes of data in sub-second times. Thusly then, the amount was not the issue the format was. Whatever that format was it had to be serializable and it had to be generic. I had to accomplish two(2) things: 1) construct a request that I wished my NETLOADed module to perform 2) provide for data interchange. The solution here is a plain’ol .NET dataset. In fact, all I really had to do was encapsulate a dataset inside a field in a “control” dataset. I could then pass one(1) serializabe object that had both a request/task and corresponding data. In my mind at least, very clean, very straightforward, and very generic.

The following is the structure I decided upon for my environment:


public static DataSet MaterializeNPControlDataSet()
    {
    DataSet _ds = new DataSet("NPCONTROLDATASET");
    _ds.RemotingFormat = SerializationFormat.Binary;
    _ds.SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;

    _ds.Tables.Add("NPCONTROLTABLE");
    DataColumn dc1 = new DataColumn("ID", typeof(Int32));
    DataColumn dc2 = new DataColumn("TEXT", typeof(string));
    DataColumn dc3 = new DataColumn("PAYLOADTEXT", typeof(string));
    DataColumn dc4 = new DataColumn("PAYLOAD", typeof(object));
    _ds.Tables[0].Columns.Add(dc1);
    _ds.Tables[0].Columns.Add(dc2);
    _ds.Tables[0].Columns.Add(dc3);
    _ds.Tables[0].Columns.Add(dc4);
    return _ds;
    }

To support the manipulation of this structure there is one(1) class. All of the serialization/de-seriaization and encapsulations are done with this class. Below are the “putter” and “getter” methods for the dataset that is encapsulated within the “PAYLOAD” field. In addition there are numerous other helper methods within the class.
”putter”


public static void SetNPControlTablePayLoad(ref DataSet _NPds, ref DataSet _payload)
    {
        byte[] ba = SerializeDataSet(ref _payload);
        _NPds.Tables["NPCONTROLTABLE"].Rows[0]["PAYLOAD"] = (object)ba;
    }

“getter”


public static DataSet ExtractNPCTablePayLoad(ref DataSet _NPds)
    {
        DataSet ads = null;
        object o = (object)_NPds.Tables["NPCONTROLTABLE"].Rows[0]["PAYLOAD"];
        if (o != System.DBNull.Value)
        {
            ads = ExtractSerializedDataSet((byte[])o);
            if (ads != null)
                return ads;
            else
                return null;
        }
            else
                return null;
    }

No, I did not implement any compression of the datasets, just the BinaryFormatter.


       public static byte[] SerializeDataSet(ref DataSet _ds)
        {
            _ds.RemotingFormat = SerializationFormat.Binary;
            _ds.SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
            MemoryStream ms = new MemoryStream();
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(ms, _ds);
            if (ms.Length > 0)
                return ms.ToArray();
            else
                return null;
        }

The Named Pipes
Ivan’s implementation is a work of art. I really hated to touch it. (Not only because it was well put together but I really did not fully comprehend his threading architecture). However, I really needed event hooks because this wasn’t going to be a “classic” Client/Server application. The applications that were going to be incorporating this were going to be operating in and supporting the user interface world. Since Ivan had architected this with interfaces I went about some touch up. (four lines of code with some big ideas ...)
Source code (C#):


using System;
namespace AppModule.InterProcessComm {
    // Delegates for events that your component will use to communicate
    // values to the form
     public delegate void ReceiveCompleteHandler(byte[] ba);
     public delegate void StatusActivityHandler(string info);

public interface IChannelManager {
        // events that this (class)component will use to communicate with the app
        event ReceiveCompleteHandler OnReceiveComplete;
        event StatusActivityHandler OnStatusActivity;

  void Initialize();
  void Stop();
  string HandleRequest(string request);
  bool Listen {get; set;}
  void WakeUp();
        void RemoveServerChannel(object param);
    }
}

Since I had decided to have both a Client and a Server incorporated within each app I made it easier on myself and just constructed an “A” and “B” dispatcher (I wanted to get rid of this Client/Server label). One would be owned by the “bridge” the other would be owned by the “other” application.
They are really nothing more than containers for Ivan’s public static IChannelManager PipeManager; I just added a few constants to make life easier and to set the “ReadOn” pipe and the “SendOn” pipe. I really didn’t want any confusion later on.

PipeManager’s most significant modifications had to do with the Events hooks:
Source code (C#):


if (numChannels <= NumberPipes) // =>
{
 ServerNamedPipe pipe = new ServerNamedPipe(PipeName, OutBuffer, InBuffer, MAX_READ_BYTES, false);
 // subscribe to the events raised when data has been gotten
 pipe.GotNewByteArray += new OnNewByteArrayHandler(pipe_GotNewByteArray);
 pipe.GotActivity += new OnActivityToReportHandler(pipe_GotActivity);
 try
 {
  pipe.Connect();
  pipe.LastAction = DateTime.Now;
  System.Threading.Interlocked.Increment(ref numChannels);
  pipe.Start();
  Pipes.Add(pipe.PipeConnection.NativeHandle, pipe);
 }
 catch (InterProcessIOException ex) {
  RemoveServerChannel(pipe.PipeConnection.NativeHandle);
  // unsubscribe to the events raised when data has been gotten
  pipe.GotNewByteArray -= new OnNewByteArrayHandler(pipe_GotNewByteArray);
  pipe.GotActivity -= new OnActivityToReportHandler(pipe_GotActivity);
  pipe.Dispose();
 }
}
else {
 Mre.Reset();
 Mre.WaitOne(1000, false);
}

Now, I just pass it on up the chain to “whatever” has hooked up.
Source code (C#):


void pipe_GotActivity(object sender, string activity)
{
 if (OnStatusActivity.Target is System.Windows.Forms.Control)
    {
       // make sure execution is done on the UI thread
       System.Windows.Forms.Control t = OnStatusActivity.Target as System.Windows.Forms.Control;
             t.BeginInvoke(OnStatusActivity, new Object[] { activity });
    }
    else
        // object from the invocation list isn't a UI thread.
        OnStatusActivity(activity);
       }
}
void pipe_GotNewByteArray(object sender, byte[] ba)
{
 string rcvszdttm = string.Format("Received: {0} bytes at {1}", ba.Length.ToString(), DateTime.Now);
    // tell whoever that a worker has just sent us a byte array
    pipe_GotActivity(this, rcvszdttm);
    //
    // determine if the object on which this delegate was invoked is a UI thread
    // if the object is a control, then the object is a UI thread
    //
    if (OnReceiveComplete.Target is System.Windows.Forms.Control)
    {
     // make sure execution is done on the UI thread
        System.Windows.Forms.Control t = OnReceiveComplete.Target as System.Windows.Forms.Control;
        t.BeginInvoke(OnReceiveComplete, new Object[] { ba });
    }
    else // object from the invocation list isn't a UI thread.
        OnReceiveComplete(ba);        
}

Finally public sealed class ServerNamedPipe had to be tweaked. In this implementation I always send an acknowledgment string after a receipt. It is client/server after all. So it is a receive binary / send a string.
Source code (C#):


public event OnNewByteArrayHandler GotNewByteArray;
public event OnActivityToReportHandler GotActivity;
 private void PipeListener() {
  CheckIfDisposed();
  try {
   Listen = DspchrHandlerA.PipeManager.Listen;
   string myName = "Pipe_" + this.PipeConnection.NativeHandle.ToString();
   GotActivity(new object(), myName + " :new pipe started");
   while (Listen)
   {
    LastAction = DateTime.Now;
    byte[] request = PipeConnection.ReadBytes();
    LastAction = DateTime.Now;
    
     // pipe manager gets the data
     GotNewByteArray(this, request);
     // this goes to the sender's listener to signal OK
     PipeConnection.Write("ACKNOWLEDGEMENT " + request.Length.ToString() + " bytes");
     //pipe manager get more info
     GotActivity(new object(), myName + " acknowledgement sent for receipt of " + request.Length.ToString() + " bytes");

    LastAction = DateTime.Now;
    PipeConnection.Disconnect();
    if (Listen) {
     GotActivity(new object(), myName + " :listening");                        
     Connect();
    }
    //
    DspchrHandlerA.PipeManager.WakeUp();
   }
  } 
  catch (System.Threading.ThreadAbortException ex) { }
  catch (System.Threading.ThreadStateException ex) { }
  catch (Exception ex) { 
   // Log exception
  }
  finally {
   this.Close();
  }
 }

Believe me named pipes and threads are NOT my specialty. I just had to know and do just enough to make it work for me. Yes, I am sure there are different and probably better ways. But I am a pragmatist and was not doing this for fun.

So we now have our pipes and we have an A and a B configuration. It matters not who is who but obviously partners cannot have the same configuration. As a final note these configurations are coded to operate on one workstation. You can of course run across different machines but that is a whole different topic.

The Data Bridge
This is the Form that will be instantiated from our NETLOADed module. As I mentioned before I wanted this to be as simple and generic as possible. Just a couple public Queue objects and a few events. I did add some UI Controls to play with during debug and never took them out.

How it works:

Receive an entry on “my” pipe
EnQueue the entry into the Suspense Queue
Fire off an OnReceivedQueueEntry event

Receive an OnCompletedTask event
DeQueue the entry from the Process queue
Send it on to the other “Server’

If there is a simpler approach I could not think of it. Since a picture is worth so many words…

And the entire source sans the UI controls for the bridge:


using System;
using System.Data;
using System.Drawing;
using System.ComponentModel;
using System.Windows.Forms;
using System.Collections;

using DspchrHandlers;
using Dspchr;

namespace DataBridge
{
    public partial class DataBridge : Form
    {
        public delegate void ReceivedQueueEntryHandler(object sender);
        public event ReceivedQueueEntryHandler OnReceivedQueueEntry;

        public Queue SuspenseQ;
        public Queue ProcessQ;

        public SendVia SendViaX;
        IDataBridge iDataBridgeClient;

        public DataBridge(IDataBridge parent)
        {
            InitializeComponent();
            iDataBridgeClient = parent; 
            DspchrHandlerA.StartServer();
            SuspenseQ = new Queue();
            ProcessQ = new Queue();
            SendViaX = new SendVia();
            DspchrHandlerA.PipeManager.OnReceiveComplete += new AppModule.InterProcessComm.ReceiveCompleteHandler(PipeManager_OnReceiveComplete);
            DspchrHandlerA.PipeManager.OnStatusActivity += new AppModule.InterProcessComm.StatusActivityHandler(PipeManager_OnStatusActivity);
            iDataBridgeClient.OnCompletedTask += new CompletedTaskHandler(iDataBridgeClient_OnCompletedTask);
        }

        void iDataBridgeClient_OnCompletedTask(object sender)
        {
            lblPQCnt.Text = ProcessQ.Count.ToString();
            string rtn_result = null;
            if (ProcessQ.Count > 0)
            {
                rtn_result = SendViaX.WriteBytes(DspchrHandlerA.SendOnPipeName, DspchrHandlerA.ServerName, (byte[])ProcessQ.Dequeue());
                txtActivity.AppendText(rtn_result + Environment.NewLine);
            }
            lblPQCnt.Text = ProcessQ.Count.ToString();
            lblSQCnt.Text = SuspenseQ.Count.ToString();
        }       
        //
        void PipeManager_OnStatusActivity(string info)
        {
            txtActivity.AppendText(info + Environment.NewLine);
        }
        void PipeManager_OnReceiveComplete(byte[] ba)
        {
            SuspenseQ.Enqueue(ba);
            lblSQCnt.Text = SuspenseQ.Count.ToString();
            Application.DoEvents();
            OnReceivedQueueEntry(this);
        } 
        private void DataBridge_FormClosing(object sender, FormClosingEventArgs e)
        {
            DspchrHandlerA.StopServer();
        }
        //
        // Some form relate stuff to mess around with
        //
        private void btnRmvSQE_Click(object sender, EventArgs e)
        {
            if (SuspenseQ.Count > 0) SuspenseQ.Dequeue();
            lblSQCnt.Text = SuspenseQ.Count.ToString();
        }
        private void btnRmvPQE_Click(object sender, EventArgs e)
        {
            if (ProcessQ.Count > 0) ProcessQ.Dequeue();
            lblPQCnt.Text = ProcessQ.Count.ToString();
        }
        private void btnReturnSQE_Click(object sender, EventArgs e)
        {
            string rtn_result = null;
            if (SuspenseQ.Count > 0)
            {
                rtn_result = SendViaX.WriteBytes(DspchrHandlerA.SendOnPipeName, DspchrHandlerA.ServerName, (byte[])SuspenseQ.Dequeue());
                lblSQCnt.Text = SuspenseQ.Count.ToString();
                txtActivity.AppendText(rtn_result + Environment.NewLine);
            }
        }
        private void btnCLEARLOG_Click(object sender, EventArgs e)
        {
            txtActivity.Clear();
        }
    }
}

The last piece of the puzzle is this interface object for the DataBridge so it knows that there was something to be done.


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

public delegate void CompletedTaskHandler(object sender);
public interface IDataBridge
{
    event CompletedTaskHandler OnCompletedTask;
}

And a skeleton of a NETLOADable dll:


namespace ADSKDATABRIDGE
{
    public class WRKR : IDataBridge
    {
        public event CompletedTaskHandler OnCompletedTask;
        public DataBridge.DataBridge DataBridgeForm;

        private static object TestForDuplication = null;
        public WRKR() { }
        
        [CommandMethod("DOPUTGET")]
        public void dome() 
        {
            if (TestForDuplication == null)
            {
                DataBridgeForm = new DataBridge.DataBridge(this);
                TestForDuplication = DataBridgeForm;
                DataBridgeForm.FormClosing += new FormClosingEventHandler(DataBridgeForm_FormClosing);
                DataBridgeForm.OnReceivedQueueEntry += new DataBridge.DataBridge.ReceivedQueueEntryHandler(DataBridgeForm_OnReceivedQueueEntry);
                DataBridgeForm.Show();
            }
        }
        void DataBridgeForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            DataBridgeForm.OnReceivedQueueEntry -= new DataBridge.DataBridge.ReceivedQueueEntryHandler(DataBridgeForm_OnReceivedQueueEntry);
            TestForDuplication = null;
        }

Finally … we receive our task and do it


        void DataBridgeForm_OnReceivedQueueEntry(object sender)
        {
            Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
            Editor ed = doc.Editor;
            bool GONOGO = true;
            DataSet CntrlDS;
            DataSet ToDoDS;
            byte[] RtnVal = null;
            if (this.DataBridgeForm.SuspenseQ.Count > 0)
            {
                while (GONOGO && this.DataBridgeForm.SuspenseQ.Count > 0)
                {
                    object o = DataBridgeForm.SuspenseQ.Dequeue();
                    try
                    {
                        CntrlDS = NPC.ExtractSerializedDataSet((byte[])o);
                        if (CntrlDS != null)
                        {
                            if (NPC.HasPayLoad(ref CntrlDS))
                            {
                                ToDoDS = NPC.ExtractNPCTablePayLoad(ref CntrlDS);
                                if (ToDoDS != null)
                                {
                                    RtnVal = ProcessRequest(ref CntrlDS, ref ToDoDS);
                                }
                            }
                        }
                        if (RtnVal != null)
                            DataBridgeForm.ProcessQ.Enqueue(RtnVal);
                        OnCompletedTask(this);
                        RtnVal = null;
                    }
                    catch (System.Exception _Ex)
                    {
                        ed.WriteMessage("ERROR: " + _Ex.Message + "\r\n");
                    }
                } // end while GONOGO
            }// if count in queue
        }// OnReceivedQueueEntry
}//eoc WRKR
} // eons

Harvesting Autodesk DWG Entities

2008-10-23T11:46:00.028+02:00

Author: Jonio, Dennis

This kicks off a series of articles on building SDO_GEOMETRY types from DWG entities. By series end you should have at least one working NETLOADable module for a template. I do not pretend that this is THE solution. Since this was completed, I have, of course, realized better ways to do some things and I am sure you will be able to find more. I strongly recommend that you look over the Oracle OTN forums in particular .NET and Spatial. The heart and soul of these UDT’s came from there. Another indispensable forum is the Autodesk Discussion Groups. Their .NET forum is also indispensable.

Oracle SDO_GEOMETRY and a few others as User Defined Types (UDT’s)

Included below are a couple projects NetSdoGeometry and NetSdoDimArray. These are the fundamental classes and I have posted these in the past. However since that time I have added an AsText property and the ToString() method. It became necessary to actually visualize the objects during development. I must also point out that SDO_GEOMETRY is now marked as [Serializable]. You will see later on that this allows for the inclusion of this type into a native .NET serializable dataset. I have included a fair number of non-essential members and methods. They are for convenience so the purist may wish to strip them.

Triplets and Triplet Management

In order to make any sense of this article you will have to have a copy of Oracle’s SDO_GEOMETRY specification and my implementation of the class NetSdoGeometry.sdogeometry.

Let me clarify, in general terms, what this implementation does and does not do in regards the specification

Is Limited to two(2) dimensional geometries. Points, lines, surfaces(polygons)
Does not include “compound-type” geometries
Does include support for curves/arcs

After reviewing the spec you will realize it is all about “triplets”. The SDO_DIM_ELEM_ARRAY is of course a 1-> n series of 3 element integers groups. OFFSET - ETYPE -INTERPRETATION as the named components.

The manipulation of the ordinates array I found to be rather trivial both in terms of composition and decomposition. It is nothing more than that a left to right series of numbers.

“Triple Management” becomes the focus. Since I was learning the spec and writing code to it as I went along, the first class I created was, of course, “Triplet”. This class helped me visualize and understand the key elements of the specification. It is nothing more than codifying the obvious. The only oddity is my use of a GUID to track external or internal rings. The idea here will be explained later. In most cases a triplet acts as a kind’a sort’a header. A header that explains the ordinate array that is part of the SDO_GEOMETRY class. It would be just that simple if all one wished to do was work with linestrings. It is the support for curves/arcs that really adds a level of complexity by using a series of triplets to denote the transitions from line to arc, arc to line, etc.

Class “Pts” is a simple container for holding the ordinates. Of note here is the BulgeValue member. This acts as the placeholder for the arc information gotten from, in my case Map3d.

Finally class “TripletMgr” or Triplet Manager if you will. Before I discuss this class I will give you a chance to see how it is used. I do not use it for points and simple lines. Really unnecessary in those cases. This code decomposes as MPolygon into an sdogeometry. Frankly if you understand this one the rest is easy.

Here is the basic idea:

  
        public static sdogeometry PolygonGeometryFromMPolygon(MPolygon mpoly)
        {
            sdogeometry sdo = null;
            Point2dCollection p2dColl = new Point2dCollection();
            int hasBulgesCount;
            int totalOrdinatesWritten = 0;                  // The total ordinates in the array
            int totalSubElementCount = 0;                   // Just the total of sub-elements
            int OWNERSHIP = 1;                              // Manage the OFFSET for a triplet 
            LoopDirection loopdirection;

            TripletMgr MasterTripletMgr = new TripletMgr();
            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;
                // 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);
                    }
                }
                //
                Point2d[] pts = new Point2d[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);
                        pts[z] = new Point2d(X, Y);
                    }
                    blgs[z] = mPolygonLoop[z].Bulge;
                    if (blgs[z] != 0.0)
                        hasBulgesCount = hasBulgesCount + 1;
                }
                // dej 2008/12/17
                // Some fixup for starting and/or ending with an arc in that the bulges get duplicated
                // along with the vertices. This also seems to be a bigger issue with "Inner" vs "Outer"
                // loops. Obviously if we have a series of arcs they won't have dup values anyway.
                // We must not decrement hasBulgesCount!!!
                if (blgs[0] == blgs[mPolygonLoop.Count - 1])
                    blgs[mPolygonLoop.Count - 1] = 0.0;

                //
                // Finished getting all the ordinates and bulges for this loop
                //
                // Just a dummy triplet to work with and begin the process of formulation
                // Each loop needs its own header triplet.
                // Establish the ETYPE and the OWNERSHIP(OFFSET) marker for this header
                // and its INTERPRETATION
                int headerOffset = (i == 0) ? 1 : OWNERSHIP;
                Triplet dummy_headerTriplet = new Triplet(new int[] { headerOffset, 0, 0 });
                if (hasBulgesCount == 0)
                    dummy_headerTriplet.INTERPRETATION = 1; // all "lines"
                else if (hasBulgesCount == pts.Length)
                    dummy_headerTriplet.INTERPRETATION = 2; // all "arcs"
                // if it is not a 1 or 2 we have to fill the INTERPRETATION value in later
                // because it contains the number of subelements
                if (loopdirection == LoopDirection.Exterior)
                {
                    // It is an exterior
                    if (dummy_headerTriplet.INTERPRETATION == 1 || dummy_headerTriplet.INTERPRETATION == 2)
                    {
                        dummy_headerTriplet.ETYPE = 1003;
                    }
                }
                else
                {
                    // It is an interior
                    if (dummy_headerTriplet.INTERPRETATION == 1 || dummy_headerTriplet.INTERPRETATION == 2)
                    {
                        dummy_headerTriplet.ETYPE = 2003;
                    }
                }
                // We have not set the etype yet so it must be a 1005 0R 2005 - compound polygon
                // dej 2008/12/17 if (dummy_headerTriplet.ETYPE == 0)
                if (dummy_headerTriplet.ETYPE == 0 || hasBulgesCount > 0)
                {
                    if (loopdirection == LoopDirection.Exterior)
                        dummy_headerTriplet.ETYPE = 1005;
                    else
                        dummy_headerTriplet.ETYPE = 2005;
                }
                //
                // Every time we make a transition from/to a curve/line we will make up a triplet
                //
                // We new-up a triplet mgr for these subelements within this loop
                // We do know that the etype MUST be a 2 - line or arc
                //
                TripletMgr tmgr = new TripletMgr();
                Triplet nxtTriplet = null;
                int currentINTERPRETATION = 0;
                int lastwrittenINTERPRETATION = 0;
                Point2d somePointOnArc;
                Point2d arc_endpoint;
                for (int j = 0; j < mPolygonLoop.Count; j++)
                {
                    double theBulge = blgs[j];
                    //Test the bulge
                    if (theBulge != 0.0)
                    {
                        // Look ahead to get the endpoint for the arc
                        if (j == (mPolygonLoop.Count - 1))
                            arc_endpoint = pts[0];
                        else
                            arc_endpoint = pts[j + 1];

                        CircularArc2d ca2d = new CircularArc2d(pts[j], arc_endpoint, theBulge, false);
                        //
                        // Get the center point on the arc ....
                        // As an alternative:/ Point2d[] somePointSOnArc = ca2d.GetSamplePoints(3);
                        // The somePointSOnArc[1] element will have the centerpoint on the arc
                        //
                        Interval interval_of_arc = ca2d.GetInterval();
                        somePointOnArc = ca2d.EvaluatePoint(interval_of_arc.Element / 2);
                        currentINTERPRETATION = 2;
                    }
                    else
                    {
                        currentINTERPRETATION = 1;
                    }
                    // This only happens once per loop/ring because nxtTriplet is no longer null
                    // We use this to start off the tracking transitions from-to curves/lines
                    if (nxtTriplet == null)
                    {
                        int elementOffset = (i == 0) ? 1 : OWNERSHIP;
                        nxtTriplet = new Triplet(new int[] { elementOffset, 2, currentINTERPRETATION });
                        lastwrittenINTERPRETATION = currentINTERPRETATION;
                    }
                    // Now collect the points and if we have a bulge add the midpoint only 
                    // and not the endpoint that will be next
                    p2dColl.Add(pts[j]);
                    totalOrdinatesWritten = totalOrdinatesWritten + 2;
                    OWNERSHIP = OWNERSHIP + 2;
                    if (theBulge != 0.0)
                    {
                        p2dColl.Add(new Point2d(somePointOnArc.ToArray()));
                        totalOrdinatesWritten = totalOrdinatesWritten + 2;
                        OWNERSHIP = OWNERSHIP + 2;
                        // Oracle must be made happy.
                        // OK this is really tricky ... the next item may or may not have a bulge
                        // if the next item is at the end and it has a bulge this is a circle!
                        // If it does not it is a line and we must loop back up so we make the proper
                        // switch on interp and get the OWNERSHIP value correct. Otherwise
                        // our OWNERSHIP value will be off by 2
                        // 
                        if ((j + 1) == (mPolygonLoop.Count - 1))
                        {
                            if (blgs[j + 1] != 0.0)
                            {
                                p2dColl.Add(pts[j + 1]);
                                totalOrdinatesWritten = totalOrdinatesWritten + 2;
                                OWNERSHIP = OWNERSHIP + 2;
                                j = j + 1;
                            }
                        }
                    }
                    //
                    // Now we construct an additional triplet in the event we have changed INTERPRETATION
                    //
                    if (currentINTERPRETATION != lastwrittenINTERPRETATION)
                    {
                        tmgr.TripletList.Add(nxtTriplet);
                        totalSubElementCount++;
                        // 
                        // If I am transitioning to an arc/curve my ownership actually started
                        // 4 ordinates ago or 2 ordinates ago in the case of a line
                        //
                        int elementOffset = (currentINTERPRETATION == 2) ? (OWNERSHIP - 4) : OWNERSHIP - 2;
                        nxtTriplet = new Triplet(new int[] { elementOffset, 2, currentINTERPRETATION });
                        lastwrittenINTERPRETATION = currentINTERPRETATION;
                    }
                }   // end of for-loop on vertex count ... finished with one of the rings.
                //
                // Add this last triplet no matter what
                //
                tmgr.TripletList.Add(nxtTriplet);
                totalSubElementCount++;
                //
                // If we are a 1005 or a 2005 we must fix-up the header triplet to reflect
                // the total number of triplets(subelements) that are present. In this case it
                // gets stuffed into the INTERP position.
                // In the end the Master will hold the entire polygon
                //
                if (tmgr.TripletCount > 1)
                {
                    dummy_headerTriplet.INTERPRETATION = totalSubElementCount;
                    MasterTripletMgr.TripletList.Add(dummy_headerTriplet);
                    for (int x = 0; x < tmgr.TripletCount; x++)
                    {
                        MasterTripletMgr.TripletList.Add(tmgr.TripletList[x]);
                    }
                }
                //
                // If we are a 1003 or a 2003
                //
                if (tmgr.TripletCount == 1)
                {
                    MasterTripletMgr.TripletList.Add(dummy_headerTriplet);
                }
                // Set for next ring ...
                totalSubElementCount = 0;
            }// for each loop in the mpolygon
            //
            // We should have the geometry for the entire MPolygon described
            // Construct the sdo_geometry object
            //
            sdo = new sdogeometry();
            sdo.Dimensionality = (int)sdogeometryTypes.DIMENSION.DIM2D;
            sdo.ElemArrayOfInts = MasterTripletMgr.ElementInfoToArray;
            double[] rtnval = new double[p2dColl.Count * 2];
            for (int w = 0, cnt = 0; w < p2dColl.Count; w++)
            {
                rtnval[cnt++] = p2dColl[w].X; rtnval[cnt++] = p2dColl[w].Y;
            }
            sdo.OrdinatesArrayOfDoubles = rtnval;
            sdo.GeometryType = (int)sdogeometryTypes.GTYPE.POLYGON;
            sdo.PropertiesToGTYPE();
            return sdo;
        }

The method SetPts is the workhorse. Once again it is the management of the triplets. The concept of “ownership” can from Pro Oracle Spatial for Oracle Database 11g, by Kothuri, Godfrind, Beinat. This really helped me put some of the pieces together. I recommend it highly.

Source code (C#) available for download at:

http://tf-net.googlecode.com/files/Triplet_Pts_TripletMgr.zip

Working with Oracle UDT’s with AutoCAD Map 3D

2008-08-02T14:09:00.014+02:00

Author: Jonio, Dennis

Within this series of articles I have pretty well illustrated Oracle’s ODP.NET working in "harmony" with Autodesk’s Map3d 2008. Also note that I have used Oracle XE throughout. The functionality Locator brings is certainly more than enough to build a reasonable GIS data store. I have not spent any time in outlining any of the other Oracle stored procedures like SDO_GEOM.VALIDATE_GEOMETRY_WITH_CONTEXT() these are all well documented across the internet. As I have said before, FDO is the way to go. But you still need to get that geometry built somewhere and put into a data store. "Map Export to FDO" is obviously a work in progress but hopefully will become a useful tool down the road.

Lessons Learned

Always turn Connection Pooling OFF when working with UDT’s.

Do NOT use the App.config method for UDT discovery that is described in the ODP.NET documentation. This does no work in all cases. It seems nested classes are not always resolved.

Since your UDT class assembly(s) will be referenced from, in the default case: "C:\Program Files\AutoCAD Map 3D 2008", be careful of your naming convention.

Source code (C#):


using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using System.Reflection;
using System.Collections;
using System.IO;
using System.Text;
using System.Data;
using System;
using Oracle.DataAccess.Client;
using Oracle.DataAccess.Types;
using NetSdoGeometry;

[assembly: ExtensionApplication(typeof(YOURCLEVERAPPNAME.Initialization))]
[assembly: CommandClass(typeof(YOURCLEVERAPPNAME.YOURCLEVERAPPNAME))]
namespace YOURCLEVERAPPNAME
{
    public class YOURCLEVERAPPNAME
    {
        public static string LocationOfDll;
        public static string forReadDwgFileInit = "forReadDwgFileInit.dwg";

        public YOURCLEVERAPPNAME()
        {
            Assembly callee = Assembly.GetExecutingAssembly();
            LocationOfDll = Path.GetDirectoryName(callee.Location);
        }

       [CommandMethod("YOURCLEVERAPPNAME")]
        public void mycleverapp()
        {
            Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
            Editor ed = doc.Editor;

            //
            // Must do this before any Oracle.DataAccess method calls.
            // If you start getting “First chance exceptions” in VS you know things are hosed.
            //
            Database Xdb = new Database(false, false);
            Xdb.ReadDwgFile(LocationOfDll + "\\" + forReadDwgFileInit,FileShare.ReadWrite, false, null);
            Xdb.Dispose();

            //
            // I do not understand but I needed this HERE to resolve sdo_geometry
            //
            sdogeometry NEED_HERE_TO_RESOLVE_sdogeometry = new sdogeometry();
            using (DocumentLock docLock = doc.LockDocument())
            {
                  // do whatever needs doing
            }
        }
    }//eoc YOURCLEVERAPPNAME

    public class Initialization : Autodesk.AutoCAD.Runtime.IExtensionApplication
    {
        public void Initialize()
        {
            Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;
            Assembly caller = Assembly.GetCallingAssembly();
            Assembly callee = Assembly.GetExecutingAssembly();
            string callername = caller.FullName;
            string calleename = callee.FullName;
            ed.WriteMessage("Loader: " + callername + " initialize " + calleename);
        }

        public void Terminate()
        {
            Assembly callee = Assembly.GetExecutingAssembly();
            string calleename = callee.FullName;
            Console.WriteLine("Cleaning up..." + calleename);
        }
    }//eoc Initialize
}//eons

ODP.NET 11g, Oracle XE 10.2, ObjectARX.NET, Autodesk Map3d 2008, OSGeo FDO 3.2

2008-05-30T13:57:00.004+02:00

Author: Jonio, Dennis

Just some basics to let you know my current bias. I do believe that FDO is the way of the way to go. Without a doubt this is the correct track to be on. Just like everything else however, it has a way to go to get to maturity. I do not like the Autodesk FDO provider for Oracle. IMHO, Haris Kurtagic’s King.Oracle Provider is the way to go. Of course his, FDO2FDO is essential and an excellent piece of work.

That being said I really did not wish to deal with all the "weight" that FDO brings to every application. So I thought I would code up an application that moved DWG geometry to an Oracle table. It seemed to me to be a fairly straightforward task since I had put together that UDT for MDSYS.SDO_GEOMETRY. I always wondered why I had not seen some code examples of doing this. Well folks, now I know...

ODP does not play well with Map3d. For those of you who do ObjectARX.NET applications there are significant problems in heap management between ODP and Map3d. The basic premise of this app is to open a DWG as an "aside" using ReadDwgFile(), iterate the geometry, convert it to the correct format and insert it into the table. Let me "cut to the chase" on this one. It ended up that I had to "load" a DWG before any call was made to any ODP.NET classes. (In all fairness to Autodesk they are very clear in that they do not support these foreign database access methods within there architecture.) Once this is done there is no difficulty. I am able to iterate through a list of DWG’s and instantiate the database with ReadDwgFile() any number of times. At least in my case the acad.exe heap is now toast. For example, if after netloading and executing my app I attempt to use FDO within Map 3D it will fail. Just restart Map 3D and all is fine.

I had set up my sdogeometry UDT in a separate class being that I did not wish to duplicate the code across any number of applications. This is of course doable but I had a very frustrating time getting ODP.NET to "see" my UDT class within the Map3d environment. As the documentation reads, Oracle.Access.Client does a reflection on the executing assembly and looks for the OracleCustomTypeMappingAttribute. This works great if your UDT class is internal to your assembly. If you have an external class assembly the alternative is to set up an xml App.config file that Client will look for or add an entry to the machine.config. I never got this to work. I found that I had to actually instantiate an NetSdoGeometry.sdogeometry object within the [CommandMethod("????")] decorated method. Wow … NOT a big sacrifice but it did take me some time to come up with the correct timings.

To do the conversions from Map3d I first used TF.NET to convert to a JTS IGeometry object and to Maksim’s credit this seems to work well. (I did, however, take the time to code up emulating a circle as a linestring.) To do the conversion to sdogeometry I used Oracle’s JGeometry object. Remember I am working with Oracle XE 10.2 and it does not come with the builtin JVM so WKB/WKT are there but return nothing. I choose not to use the monoGIS distribution and did the IKVM byte code conversions myself using the most current JGeometry version I could find. Since I was only interested in the WKB/WKT methods I was not too concerned with the warnings coming out of IKVM. I forget the compile order but I needed these 4: sdoapi, sdoutl, xmlparserv2 and ojdbc5.

At this point a have a fully functional application. Not the fastest piece of code I have done but I certainly do exercise TF.NET. The next step will be to code up the load of the sdogeometry objects directly. But, I am in no hurry. Computer cycles are a lot cheaper than my time.

Oracle's SDO_DIM_ARRAY as UDT and utilizing SDO_MIGRATE.TO_CURRENT as stored procedure

2008-05-30T12:44:00.009+02:00

Author: Jonio, Dennis

Utilizing Oracle’s latest ODP for .NET the following is one implementation of the SDO_DIM_ARRAY and SDO_DIM_ELEMENT type(s) as a .NET class.

This one is easy to explain. I needed to use SDO_MIGRATE.TO_CURRENT to fix some ORA-13367: wrong orientation for interior/exterior rings errors. So I needed SDO_DIM_ARRAY and thusly SDO_DIM_ELEMENT because SDO_MIGRATE.TO_CURRENT requires a SDO_DIM_ARRAY as a parameter. I have included my method of utilizing SDO_MIGRATE.TO_CURRENT after the class definitions.

Source code (C#):


using System;
using System.Collections;
using System.Text;
using Oracle.DataAccess.Client;
using Oracle.DataAccess.Types;

namespace NetSdoDimArray
{
    /// 
    /// ////////////////////////////////////
    /// sdodimarray
    /// ////////////////////////////////////
    /// 

    public class sdodimarray : IOracleCustomType, INullable
    {
        [OracleObjectMapping(0)]
        public sdodimelement[] _dimelements;
        private bool m_bIsNull;

        public bool IsNull
        {
            get
            {
                return m_bIsNull;
            }
        }

        public sdodimelement[] DimElements
        {
            get
            {
                return _dimelements;
            }
            set
            {
                _dimelements = value;
            }
        }

        public static sdodimarray Null
        {
            get
            {
                sdodimarray obj = new sdodimarray();
                obj.m_bIsNull = true;
                return obj;
            }
        }

        public override string ToString()
        {
            if (m_bIsNull)
                return "sdodimarray.Null";
            else
            {
                StringBuilder sb = new StringBuilder();
                foreach (sdodimelement i in _dimelements)
                {
                    sb.Append("sdodimelement(");
                    sb.Append(i._dimname + "=");
                    sb.Append(string.Format("{0:0.#####}", i._lb));
                    sb.Append(",");
                    sb.Append(string.Format("{0:0.#####}", i._ub));
                    sb.Append(",Tol=");
                    sb.Append(i._tolerance.ToString());
                    sb.Append(")");
                }
                return sb.ToString();
            }
        }

        public void ToCustomObject(OracleConnection con, IntPtr pUdt)
        {
            _dimelements = (sdodimelement[])OracleUdt.GetValue(con, pUdt, 0);
        }

        public void FromCustomObject(OracleConnection con, IntPtr pUdt)
        {
            OracleUdt.SetValue(con, pUdt, 0, _dimelements);
        }
    }

    [OracleCustomTypeMapping("MDSYS.SDO_DIM_ARRAY")]
    public class sdodimarrayFactory : IOracleArrayTypeFactory, IOracleCustomTypeFactory
    {
        // IOracleCustomTypeFactory Inteface
        public IOracleCustomType CreateObject()
        {
            return new sdodimarray();
        }

        // IOracleArrayTypeFactory.CreateArray Inteface
        public Array CreateArray(int numElems)
        {
            return new sdodimelement[numElems];
        }

        // IOracleArrayTypeFactory.CreateStatusArray
        public Array CreateStatusArray(int numElems)
        {
            // An OracleUdtStatus[] is not required to store null status information
            // if there is no NULL attribute data in the element array
            return null;
        }
    }

    /// 
    /// ////////////////////////////////////
    /// sdodimelement
    /// ////////////////////////////////////
    /// 

    public class sdodimelement : IOracleCustomType, INullable
    {
        [OracleObjectMapping(0)]
        public string _dimname;

        [OracleObjectMapping(1)]
        public double _lb;

        [OracleObjectMapping(2)]
        public double _ub;

        [OracleObjectMapping(3)]
        public double _tolerance;

        private bool m_bIsNull;

        public bool IsNull
        {
            get
            {
                return m_bIsNull;
            }
        }

        public static sdodimelement Null
        {
            get
            {
                sdodimelement obj = new sdodimelement();
                obj.m_bIsNull = true;
                return obj;
            }
        }

        public override string ToString()
        {
            if (m_bIsNull)
                return "sdodimelement.Null";
            else
            {
                StringBuilder sb = new StringBuilder();
                sb.Append("sdodimelement(");
                sb.Append(_dimname + "=");
                sb.Append(string.Format("{0:0.#####}", _lb));
                sb.Append(",");
                sb.Append(string.Format("{0:0.#####}", _ub));
                sb.Append(",Tol=");
                sb.Append(_tolerance.ToString());
                sb.Append(")");
                return sb.ToString();
            }
        }

        public void ToCustomObject(OracleConnection con, IntPtr pUdt)
        {
            _dimname = (string)OracleUdt.GetValue(con, pUdt, 0);
            _lb = (double)OracleUdt.GetValue(con, pUdt, 1);
            _ub = (double)OracleUdt.GetValue(con, pUdt, 2);
            _tolerance = (double)OracleUdt.GetValue(con, pUdt, 3);
        }

        public void FromCustomObject(OracleConnection con, IntPtr pUdt)
        {
            OracleUdt.SetValue(con, pUdt, 0, _dimname);
            OracleUdt.SetValue(con, pUdt, 1, _lb);
            OracleUdt.SetValue(con, pUdt, 2, _ub);
            OracleUdt.SetValue(con, pUdt, 3, _tolerance);
        }
    }

    [OracleCustomTypeMapping("MDSYS.SDO_DIM_ELEMENT")]
    public class sdodimelementFactory : IOracleCustomTypeFactory
    {
        // IOracleCustomTypeFactory Inteface
        public IOracleCustomType CreateObject()
        {
            sdodimelement sdodimelement = new sdodimelement();
            return sdodimelement;
        }
    }
}

As you see, it utilizes both sdogeometry and sdodimarray...


public static sdogeometry MigrateToCurrentSP(string connectstring, sdogeometry _geoIn, sdodimarray _toleranceIn)
        {
            //ORA-13367:      wrong orientation for interior/exterior rings
            sdogeometry rtnval = null;
            using (OracleConnection conn = new OracleConnection(connectstring))
            {
                using (OracleCommand dbcmd = conn.CreateCommand())
                {
                    dbcmd.CommandType = CommandType.StoredProcedure;
                    dbcmd.CommandText = "SDO_MIGRATE.TO_CURRENT";

                    OracleParameter cParm1 = new OracleParameter();
                    cParm1.ParameterName = "geometry";
                    cParm1.OracleDbType = OracleDbType.Object;
                    cParm1.Value = _geoIn;
                    cParm1.UdtTypeName = "MDSYS.SDO_GEOMETRY";
                    cParm1.Direction = ParameterDirection.Input;

                    OracleParameter cParm2 = new OracleParameter();
                    cParm2.ParameterName = "tolerance";
                    cParm2.OracleDbType = OracleDbType.Object;
                    cParm2.Value = _toleranceIn;
                    cParm2.UdtTypeName = "MDSYS.SDO_DIM_ARRAY";
                    cParm2.Direction = ParameterDirection.Input;

                    OracleParameter cParm3 = new OracleParameter();
                    cParm3.ParameterName = "RETURNVALUE";
                    cParm3.OracleDbType = OracleDbType.Object;
                    cParm3.UdtTypeName = "MDSYS.SDO_GEOMETRY";
                    cParm3.Direction = ParameterDirection.ReturnValue;

                    // Note the order
                    dbcmd.Parameters.Add(cParm3);
                    dbcmd.Parameters.Add(cParm1);
                    dbcmd.Parameters.Add(cParm2);

                    try
                    {
                        conn.Open();
                        dbcmd.ExecuteNonQuery();
                        rtnval = (sdogeometry)dbcmd.Parameters["RETURNVALUE"].Value;
                    }
                    catch (Exception _Ex)
                    {
                        throw (_Ex); // Actually rethrow
                    }
                    finally
                    {
                        if (conn != null && conn.State == ConnectionState.Open)
                        {
                            conn.Close();
                        }
                    }
                }//using cmd
            }//using conn

            return rtnval;
        }

A note to contributors

2007-01-13T12:04:00.008+01:00

Author: Sestic, Maksim

Inserting Source Code Snippets

Seems more complex than actually writing it :-) I embedded some tiny JavaScript source code parser in the blog head tag, here's how authors should use it to avoid article/code malformatting:

Write article body first (no source code yet) using Compose tool, leaving blank paragraphs for future source code snippets
When you have your article fully formatted, hit the Save Now button
Switch to Edit Html tool. That's how article's underlying HTML looks like
Find the spot where you want your source code snippet inserted
Open actual source file (.cs) in Visual Studio, copy the source code (Ctrl+C)
Go back to article's HTML and paste (Ctrl+V) code snippet enclosing it with <pre><\pre> tags, as in:

<pre class="c-sharp:collapse" name="code">
...your source code snippet goes here...
</pre>

In case you're posting VB.NET code snippet then replace c-sharp constructor parameter with vb. If you want your code snippet expanded by default, omit :collapse part of the constructor. But I suggest you always use collapsed source snippets due to physical message length and scrolling issues. Of course, don't forget to hit Save Now button at the end.

Topology Framework .NET (TF.NET)

2007-01-12T14:54:00.000+01:00

Author: Sestic, Maksim

Topology Framework .NET represents a topology manipulation API capable of handling managed objects representation of topological entities based on other popular APIs, exposing it's JTS-based common topology manipulation core to them.

JTS Topology Suite is, in fact, Java API providing spatial object model and fundamental geometric functions, providing a complete, consistent, robust implementation of fundamental 2D spatial algorithms. It implements geometry model defined in the OpenGIS Consortium Simple Features Specification for SQL. JTS port for .NET was named NTS, and is fully conformant to Microsoft .NET 2.0 specification. NTS extends JTS with numerous coordinate transformation and other functions, while TF.NET extends NTS further, including additional IO functions and generic classes related to geometry graphs. For details regarding described technologies and their respective authors see acknowledgements below.

Provided Functions

Spatial predicates (based on the DE-9IM model)
Overlay functions (intersection, difference, union, symmetric difference)
Buffer Convex hull
Area and distance functions
Topological validity checking
Coordinate systems manipulation (transformations)
Topological graphs manipulation
Generic geometry I/O support: WKT, WKB, GML, SHP

Supported External Managed APIs

OSGeo Feature Data Objects (FDO) geometries
OSGeo MapGuide Server (FDO-based) geometries
Autodesk ObjectARX geometries (a.k.a. entities)
Oracle Data Provider for .NET (ODP.NET) geometries - see related wiki page

Package Components Available For Download

TF.NET Core Library, a mandatory component exposing basic topology manipulation API.
TF.NET Reader/Writer for MapGuide, a reader/writer for geometric primitives exposed by OSGeo MapGuide Server.
TF.NET Reader/Writer for FDO, a reader/writer for geometric primitives exposed by OSGeo Feature Data Objects spatial library.
TF.NET Reader/Writer for ObjectARX, a reader/writer for geometric entities exposed by Autodesk AutoCAD and it's verticals.

References And Further Reading

TF.NET API Help (CHM file)
JTS Topology Suite API Help
JTS Topology Suite Technical Specifications (PDF file)
JTS Topology Suite Developer's Guide (PDF file)
JTS Topology Suite explained on The Jump Project page
References and Further Reading wiki page

Credits

TF.NET is primarily based on other people's work related to topology manipulation, hence special acknowledgement to them. Referred libraries were additionally repackaged and their namespaces renamed for easier use. Please download copyright disclaimer for detailed description.

Vivid Solutions' JTS Topology Suite
Diego Guidi's NetTopologySuite
Morten Nielsen's SharpMap
Urban Science Applications' GeoTools.NET
Jonathan de Halleux's QuickGraph
Ryan Seghers' RTools.Util
Jason Smith's Iesi.Collections
Kailuo Wang's Iesi.Collections.Generic
Bruno Lowagie and Paulo Soares' iText
Dennis Jonio for articles on ODP.NET implementation

For more information please contact project owner: Maksim Sestic