Harvesting Autodesk DWG Entities

Author: Jonio, Dennis

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

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

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

• http://tf-net.googlecode.com/files/NetSdoGeometry.zip
• http://tf-net.googlecode.com/files/NetSdoDimArray.zip

Triplets and Triplet Management

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

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

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

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

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

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

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

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

Here is the basic idea:

+ expand sourceview plainprint?

1. public static sdogeometry PolygonGeometryFromMPolygon(MPolygon mpoly)  
2. {  
3.     sdogeometry sdo = null;  
4.     Point2dCollection p2dColl = new Point2dCollection();  
5.     int hasBulgesCount;  
6.     int totalOrdinatesWritten = 0;                  // The total ordinates in the array  
7.     int totalSubElementCount = 0;                   // Just the total of sub-elements  
8.     int OWNERSHIP = 1;                              // Manage the OFFSET for a triplet   
9.     LoopDirection loopdirection;  
10.   
11.     TripletMgr MasterTripletMgr = new TripletMgr();  
12.     int loops = mpoly.NumMPolygonLoops;  
13.     for (int i = 0; i < loops; i++)  
14.     {  
15.         // Gather up points and bulges for this loop  
16.         MPolygonLoop mPolygonLoop = mpoly.GetMPolygonLoopAt(i);  
17.         loopdirection = mpoly.GetLoopDirection(i);  
18.         hasBulgesCount = 0;  
19.         // Remove duplicate verticies  
20.         for (int d = 1; d < mPolygonLoop.Count - 1; d++)  
21.         {  
22.             if (mPolygonLoop[d].Vertex.IsEqualTo(mPolygonLoop[d + 1].Vertex))  
23.             {  
24.                 mPolygonLoop.RemoveAt(d + 1);  
25.             }  
26.         }  
27.         //  
28.         Point2d[] pts = new Point2d[mPolygonLoop.Count];  
29.         double[] blgs = new double[mPolygonLoop.Count];  
30.         for (int z = 0; z < mPolygonLoop.Count; z++)  
31.         {  
32.             if (z == mPolygonLoop.Count - 1)  
33.             {  
34.                 pts[z] = pts[0];  
35.             }  
36.             else  
37.             {  
38.                 double X = Math.Round(mPolygonLoop[z].Vertex.X, 10, MidpointRounding.AwayFromZero);  
39.                 double Y = Math.Round(mPolygonLoop[z].Vertex.Y, 10, MidpointRounding.AwayFromZero);  
40.                 pts[z] = new Point2d(X, Y);  
41.             }  
42.             blgs[z] = mPolygonLoop[z].Bulge;  
43.             if (blgs[z] != 0.0)  
44.                 hasBulgesCount = hasBulgesCount + 1;  
45.         }  
46.         // dej 2008/12/17  
47.         // Some fixup for starting and/or ending with an arc in that the bulges get duplicated  
48.         // along with the vertices. This also seems to be a bigger issue with "Inner" vs "Outer"  
49.         // loops. Obviously if we have a series of arcs they won't have dup values anyway.  
50.         // We must not decrement hasBulgesCount!!!  
51.         if (blgs[0] == blgs[mPolygonLoop.Count - 1])  
52.             blgs[mPolygonLoop.Count - 1] = 0.0;  
53.   
54.         //  
55.         // Finished getting all the ordinates and bulges for this loop  
56.         //  
57.         // Just a dummy triplet to work with and begin the process of formulation  
58.         // Each loop needs its own header triplet.  
59.         // Establish the ETYPE and the OWNERSHIP(OFFSET) marker for this header  
60.         // and its INTERPRETATION  
61.         int headerOffset = (i == 0) ? 1 : OWNERSHIP;  
62.         Triplet dummy_headerTriplet = new Triplet(new int[] { headerOffset, 0, 0 });  
63.         if (hasBulgesCount == 0)  
64.             dummy_headerTriplet.INTERPRETATION = 1; // all "lines"  
65.         else if (hasBulgesCount == pts.Length)  
66.             dummy_headerTriplet.INTERPRETATION = 2; // all "arcs"  
67.         // if it is not a 1 or 2 we have to fill the INTERPRETATION value in later  
68.         // because it contains the number of subelements  
69.         if (loopdirection == LoopDirection.Exterior)  
70.         {  
71.             // It is an exterior  
72.             if (dummy_headerTriplet.INTERPRETATION == 1 || dummy_headerTriplet.INTERPRETATION == 2)  
73.             {  
74.                 dummy_headerTriplet.ETYPE = 1003;  
75.             }  
76.         }  
77.         else  
78.         {  
79.             // It is an interior  
80.             if (dummy_headerTriplet.INTERPRETATION == 1 || dummy_headerTriplet.INTERPRETATION == 2)  
81.             {  
82.                 dummy_headerTriplet.ETYPE = 2003;  
83.             }  
84.         }  
85.         // We have not set the etype yet so it must be a 1005 0R 2005 - compound polygon  
86.         // dej 2008/12/17 if (dummy_headerTriplet.ETYPE == 0)  
87.         if (dummy_headerTriplet.ETYPE == 0 || hasBulgesCount > 0)  
88.         {  
89.             if (loopdirection == LoopDirection.Exterior)  
90.                 dummy_headerTriplet.ETYPE = 1005;  
91.             else  
92.                 dummy_headerTriplet.ETYPE = 2005;  
93.         }  
94.         //  
95.         // Every time we make a transition from/to a curve/line we will make up a triplet  
96.         //  
97.         // We new-up a triplet mgr for these subelements within this loop  
98.         // We do know that the etype MUST be a 2 - line or arc  
99.         //  
100.         TripletMgr tmgr = new TripletMgr();  
101.         Triplet nxtTriplet = null;  
102.         int currentINTERPRETATION = 0;  
103.         int lastwrittenINTERPRETATION = 0;  
104.         Point2d somePointOnArc;  
105.         Point2d arc_endpoint;  
106.         for (int j = 0; j < mPolygonLoop.Count; j++)  
107.         {  
108.             double theBulge = blgs[j];  
109.             //Test the bulge  
110.             if (theBulge != 0.0)  
111.             {  
112.                 // Look ahead to get the endpoint for the arc  
113.                 if (j == (mPolygonLoop.Count - 1))  
114.                     arc_endpoint = pts[0];  
115.                 else  
116.                     arc_endpoint = pts[j + 1];  
117.   
118.                 CircularArc2d ca2d = new CircularArc2d(pts[j], arc_endpoint, theBulge, false);  
119.                 //  
120.                 // Get the center point on the arc ....  
121.                 // As an alternative:/ Point2d[] somePointSOnArc = ca2d.GetSamplePoints(3);  
122.                 // The somePointSOnArc[1] element will have the centerpoint on the arc  
123.                 //  
124.                 Interval interval_of_arc = ca2d.GetInterval();  
125.                 somePointOnArc = ca2d.EvaluatePoint(interval_of_arc.Element / 2);  
126.                 currentINTERPRETATION = 2;  
127.             }  
128.             else  
129.             {  
130.                 currentINTERPRETATION = 1;  
131.             }  
132.             // This only happens once per loop/ring because nxtTriplet is no longer null  
133.             // We use this to start off the tracking transitions from-to curves/lines  
134.             if (nxtTriplet == null)  
135.             {  
136.                 int elementOffset = (i == 0) ? 1 : OWNERSHIP;  
137.                 nxtTriplet = new Triplet(new int[] { elementOffset, 2, currentINTERPRETATION });  
138.                 lastwrittenINTERPRETATION = currentINTERPRETATION;  
139.             }  
140.             // Now collect the points and if we have a bulge add the midpoint only   
141.             // and not the endpoint that will be next  
142.             p2dColl.Add(pts[j]);  
143.             totalOrdinatesWritten = totalOrdinatesWritten + 2;  
144.             OWNERSHIP = OWNERSHIP + 2;  
145.             if (theBulge != 0.0)  
146.             {  
147.                 p2dColl.Add(new Point2d(somePointOnArc.ToArray()));  
148.                 totalOrdinatesWritten = totalOrdinatesWritten + 2;  
149.                 OWNERSHIP = OWNERSHIP + 2;  
150.                 // Oracle must be made happy.  
151.                 // OK this is really tricky ... the next item may or may not have a bulge  
152.                 // if the next item is at the end and it has a bulge this is a circle!  
153.                 // If it does not it is a line and we must loop back up so we make the proper  
154.                 // switch on interp and get the OWNERSHIP value correct. Otherwise  
155.                 // our OWNERSHIP value will be off by 2  
156.                 //   
157.                 if ((j + 1) == (mPolygonLoop.Count - 1))  
158.                 {  
159.                     if (blgs[j + 1] != 0.0)  
160.                     {  
161.                         p2dColl.Add(pts[j + 1]);  
162.                         totalOrdinatesWritten = totalOrdinatesWritten + 2;  
163.                         OWNERSHIP = OWNERSHIP + 2;  
164.                         j = j + 1;  
165.                     }  
166.                 }  
167.             }  
168.             //  
169.             // Now we construct an additional triplet in the event we have changed INTERPRETATION  
170.             //  
171.             if (currentINTERPRETATION != lastwrittenINTERPRETATION)  
172.             {  
173.                 tmgr.TripletList.Add(nxtTriplet);  
174.                 totalSubElementCount++;  
175.                 //   
176.                 // If I am transitioning to an arc/curve my ownership actually started  
177.                 // 4 ordinates ago or 2 ordinates ago in the case of a line  
178.                 //  
179.                 int elementOffset = (currentINTERPRETATION == 2) ? (OWNERSHIP - 4) : OWNERSHIP - 2;  
180.                 nxtTriplet = new Triplet(new int[] { elementOffset, 2, currentINTERPRETATION });  
181.                 lastwrittenINTERPRETATION = currentINTERPRETATION;  
182.             }  
183.         }   // end of for-loop on vertex count ... finished with one of the rings.  
184.         //  
185.         // Add this last triplet no matter what  
186.         //  
187.         tmgr.TripletList.Add(nxtTriplet);  
188.         totalSubElementCount++;  
189.         //  
190.         // If we are a 1005 or a 2005 we must fix-up the header triplet to reflect  
191.         // the total number of triplets(subelements) that are present. In this case it  
192.         // gets stuffed into the INTERP position.  
193.         // In the end the Master will hold the entire polygon  
194.         //  
195.         if (tmgr.TripletCount > 1)  
196.         {  
197.             dummy_headerTriplet.INTERPRETATION = totalSubElementCount;  
198.             MasterTripletMgr.TripletList.Add(dummy_headerTriplet);  
199.             for (int x = 0; x < tmgr.TripletCount; x++)  
200.             {  
201.                 MasterTripletMgr.TripletList.Add(tmgr.TripletList[x]);  
202.             }  
203.         }  
204.         //  
205.         // If we are a 1003 or a 2003  
206.         //  
207.         if (tmgr.TripletCount == 1)  
208.         {  
209.             MasterTripletMgr.TripletList.Add(dummy_headerTriplet);  
210.         }  
211.         // Set for next ring ...  
212.         totalSubElementCount = 0;  
213.     }// for each loop in the mpolygon  
214.     //  
215.     // We should have the geometry for the entire MPolygon described  
216.     // Construct the sdo_geometry object  
217.     //  
218.     sdo = new sdogeometry();  
219.     sdo.Dimensionality = (int)sdogeometryTypes.DIMENSION.DIM2D;  
220.     sdo.ElemArrayOfInts = MasterTripletMgr.ElementInfoToArray;  
221.     double[] rtnval = new double[p2dColl.Count * 2];  
222.     for (int w = 0, cnt = 0; w < p2dColl.Count; w++)  
223.     {  
224.         rtnval[cnt++] = p2dColl[w].X; rtnval[cnt++] = p2dColl[w].Y;  
225.     }  
226.     sdo.OrdinatesArrayOfDoubles = rtnval;  
227.     sdo.GeometryType = (int)sdogeometryTypes.GTYPE.POLYGON;  
228.     sdo.PropertiesToGTYPE();  
229.     return sdo;  
230. }  

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

            TripletMgr MasterTripletMgr = new TripletMgr();
            int loops = mpoly.NumMPolygonLoops;
            for (int i = 0; i < loops; i++)
            {
                // Gather up points and bulges for this loop
                MPolygonLoop mPolygonLoop = mpoly.GetMPolygonLoopAt(i);
                loopdirection = mpoly.GetLoopDirection(i);
                hasBulgesCount = 0;
                // Remove duplicate verticies
                for (int d = 1; d < mPolygonLoop.Count - 1; d++)
                {
                    if (mPolygonLoop[d].Vertex.IsEqualTo(mPolygonLoop[d + 1].Vertex))
                    {
                        mPolygonLoop.RemoveAt(d + 1);
                    }
                }
                //
                Point2d[] pts = new Point2d[mPolygonLoop.Count];
                double[] blgs = new double[mPolygonLoop.Count];
                for (int z = 0; z < mPolygonLoop.Count; z++)
                {
                    if (z == mPolygonLoop.Count - 1)
                    {
                        pts[z] = pts[0];
                    }
                    else
                    {
                        double X = Math.Round(mPolygonLoop[z].Vertex.X, 10, MidpointRounding.AwayFromZero);
                        double Y = Math.Round(mPolygonLoop[z].Vertex.Y, 10, MidpointRounding.AwayFromZero);
                        pts[z] = new Point2d(X, Y);
                    }
                    blgs[z] = mPolygonLoop[z].Bulge;
                    if (blgs[z] != 0.0)
                        hasBulgesCount = hasBulgesCount + 1;
                }
                // dej 2008/12/17
                // Some fixup for starting and/or ending with an arc in that the bulges get duplicated
                // along with the vertices. This also seems to be a bigger issue with "Inner" vs "Outer"
                // loops. Obviously if we have a series of arcs they won't have dup values anyway.
                // We must not decrement hasBulgesCount!!!
                if (blgs[0] == blgs[mPolygonLoop.Count - 1])
                    blgs[mPolygonLoop.Count - 1] = 0.0;

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

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

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

Source code (C#) available for download at:

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