(V) New SDO_GEOMETRY <-> Autodesk Map3d 2010

Author: Jonio, Dennis

As I stated in the last post:

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

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

+ expand sourceview plainprint?

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

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

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

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

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

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