(VII) New SDO_GEOMETRY <-> Autodesk Map3d 2010

Author: Jonio, Dennis

The next and last items on the list ...

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

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

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

I never output an Oracle Circle

I never output an Oracle Rectangle

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

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

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

+ expand sourceview plainprint?

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

using MDADDrawAbles;
using SDO = MDADDrawAbles.DrawAbleSdoGeometryUtil;

using NetSdoGeometry;

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

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

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

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

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

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

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

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

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

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

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

            d.SubComponents.Add(dc);

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

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

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

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

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

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

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

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

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

                DrawAbleSubComponentEType etype = cmp.Etype;
                firstPointFlag = false;

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

                    plineCompound = new Polyline();

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

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

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

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

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

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

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

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

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

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

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

    }//eoc DrawAbleDwg
}//eons