示例#1
0
文件: Stake_Wall.cs 项目: 15831944/EM
        processWall(ObjectId idAlign)
        {
            List <POI> varpoi = new List <POI>();

            Stake_GetCardinals.getCardinals_Horizontal(idAlign, ref varpoi);
            Stake_GetCardinals.checkBegAndEndStations(idAlign, ref varpoi);
            Stake_DuplicateStations.resolveDuplicateStations(ref varpoi);

            WALL_DATA wall_Data = getWallData(idAlign);

            object varPntUpper = wall_Data.PntUpper;

            List <WALL_STEP> varPOI_TOW;
            List <WALL_STEP> varPOI_TOF;

            convertWallData(wall_Data, out varPOI_TOW, out varPOI_TOF);

            List <POI> varPOI_WALL = getWallPOI(varPOI_TOW, varPOI_TOF);

            fStake.POI_STAKE = varPOI_WALL;

            ObjectId idTable = Stake_Table.makeTable(idAlign, varPOI_WALL, varPntUpper: varPntUpper);

            Stake_Table.addTableData(idTable, varPOI_WALL);
        }
示例#2
0
        private static void processWater(string nameLayer, ObjectId idPolyGuideline, BlockTableRecord ms, ref List <POI> varPOI, out ObjectId idAlign)
        {
            string    nameAlign = Align.getAlignName(nameLayer);
            Alignment align     = Align.addAlignmentFromPoly(nameAlign, nameLayer, idPolyGuideline, "Standard", "Standard", true);

            fStake.ACTIVEALIGN = align;
            idAlign            = align.ObjectId;
            fStake.objectID    = idAlign;

            Stake_GetCardinals.getCardinals_Horizontal(idAlign, ref varPOI);

            Stake_GetNestedObjects.getNestedObjects(idAlign, ref varPOI, "CNTL");

            Stake_GetCardinals.getCrossingAligns(idAlign, ref varPOI);

            varPOI         = Stake_ModifyStaking.modifyStaking(varPOI);
            fStake.POI_ORG = varPOI;

            Stake_GetCardinals.checkBegAndEndStations(idAlign, ref varPOI);

            Stake_AddProfile.makeProfile(idAlign, varPOI, "STAKE", "ByLayout", false);

            Stake_GetAnglePoints.getAnglePoints(idAlign, ref varPOI);//IDENTIFY ANGLE POINTS - CHECK IF CLOSED

            var sortSta = from s in varPOI
                          orderby s.Station ascending
                          select s;

            List <POI> poiTmp = new List <POI>();

            foreach (var s in sortSta)
            {
                poiTmp.Add(s);
            }
            varPOI = poiTmp;

            Stake_DuplicateStations.resolveDuplicateStations(ref varPOI);

            Stake_GetSurfaceElev.getSurfaceElevations(idAlign, ref varPOI);//ALL ELEVATIONS COME FROM SURFACE

            Stake_AddProfile.makeProfile(idAlign, varPOI, "STAKE", "ByLayout", true);

            if (varPOI[0].isClosed)
            {
                Stake_GetAnglePoints.addEndElev(idAlign, ref varPOI, "CPNT");
            }

            Stake_UpdateProfile.updateProfile(idAlign, varPOI, "STAKE", true, "STAKE");
            fStake.POI_CALC = varPOI;
        }
示例#3
0
        processCurb(string nameLayer, ObjectId idPolyGuideline, BlockTableRecord ms, string nameXRef, ref List <POI> varPOI, out ObjectId idAlign)
        {
            string    nameAlign = Align.getAlignName(nameLayer);
            Alignment align     = Align.addAlignmentFromPoly(nameAlign, nameLayer, idPolyGuideline, "Standard", "Standard", true);

            fStake.ACTIVEALIGN = align;
            idAlign            = align.ObjectId;
            fStake.objectID    = idAlign;

            Stake_GetCardinals.getCardinals_Horizontal(idAlign, ref varPOI);

            Stake_GetNestedObjects.getNestedPoints(idAlign, ref varPOI, ms, nameXRef);

            fStake.POI_ORG = varPOI;

            Stake_GetCardinals.getCardinals_Vertical(idAlign, ref varPOI);

            Stake_AddProfile.makeProfile(idAlign, varPOI, "CURB", "ByLayout", false); //VERTICAL CONTROL IS SET FROM POINTS

            Stake_GetAnglePoints.getAnglePoints(idAlign, ref varPOI);                 //IDENTIFY ANGLE POINTS - CHECK IF CLOSED

            Stake_GetCardinals.checkBegAndEndStations(idAlign, ref varPOI);

            if (varPOI[0].isClosed)
            {
                Stake_GetAnglePoints.addEndElev(idAlign, ref varPOI, "FLOWLINE");
            }

            Stake_GetBC_EC.getBC_EC(idAlign, ref varPOI);

            Debug.Print("BEGIN POI AFTER getBC_EC");

            for (int i = 0; i < varPOI.Count; i++)
            {
                Debug.Print(i + " " + varPOI[i].Station + " " + varPOI[i].Elevation + " " + varPOI[i].Desc0 + "   " + varPOI[i].DescX);
            }

            Debug.Print("END POI AFTER getBC_EC");

            Stake_DuplicateStations.resolveDuplicateStations(ref varPOI);

            Stake_AddProfile.makeProfile(idAlign, varPOI, "CURB", "ByLayout", true);

            Stake_UpdateProfile.updateProfile(idAlign, fStake.POI_ORG, "FLOWLINE", true, "ORG");

            Stake_UpdateProfile.updateProfile(idAlign, varPOI, "STAKE", false, "STAKE");
        }
示例#4
0
文件: Stake_Main.cs 项目: 15831944/EM
        Process(string varObjName = "")
        {
            Object xRefPath = null;
            Entity obj      = xRef.getEntity("\nSelect feature to stake: ", out escape, out xRefPath, out ps);

            fStake.XRefDbModelSpace = xRef.getXRefBlockTableRecordMS(xRefPath.ToString());
            ObjectId idAlign = ObjectId.Null;

            if (escape)
            {
                return;
            }

            ObjectId idPolyGuideline = ObjectId.Null;

            string nameLayer = "";

            switch (obj.GetType().Name)
            {
            case "Arc":
            case "Line":
            case "Polyline":
            case "Polyline2d":
            case "Polyline3d":

                idPolyGuideline = Stake_GetGuidelines.getGuidelines(obj);

                if (varObjName == "")
                {
                    nameLayer = obj.Layer;
                    int intPos = nameLayer.IndexOf("|");
                    nameLayer = nameLayer.Substring(intPos + 1);

                    fStake.NameStakeObject = nameLayer;
                }
                else
                {
                    nameLayer              = "SIDEWALK";
                    fStake.ClassObj        = "SIDEWALK";
                    fStake.NameStakeObject = "SIDEWALK";
                }

                if (nameLayer.Contains("CURB"))
                {
                    if (!testClass("CURB", nameLayer))
                    {
                        return;
                    }
                }
                else if (nameLayer.Contains("FL"))
                {
                    if (!testClass("FL", nameLayer))
                    {
                        return;
                    }
                }
                else if (nameLayer.Contains("FTG") || nameLayer.Contains("FOOTING"))
                {
                    if (!testClass("FTG", nameLayer))
                    {
                        return;
                    }
                }
                else if (nameLayer.Contains("SEWER"))
                {
                    if (!testClass("SEWER", nameLayer))
                    {
                        return;
                    }
                }
                else if (nameLayer.Contains("SD"))
                {
                    if (!testClass("SD", nameLayer))
                    {
                        return;
                    }
                }
                else if (nameLayer.Contains("WALL"))
                {
                    if (!testClass("WALL", nameLayer))
                    {
                        return;
                    }
                }
                else if (nameLayer.Contains("WATER") || nameLayer.Contains("WAT") || nameLayer.Contains("WTR") || nameLayer.Contains("FIRE") ||
                         nameLayer.Contains("VERIZON") || nameLayer.Contains("ELEC") || nameLayer.Contains("CABLE") ||
                         nameLayer.Contains("PHONE") || nameLayer.Contains("TELE"))
                {
                    if (!testClass("WTR", nameLayer))
                    {
                        return;
                    }
                }

                processAlign(nameLayer, idPolyGuideline);

                break;

            case "DbAlignment":

                List <POI> varPOI   = new List <POI>();
                Alignment  objAlign = (Alignment)obj;
                idAlign = objAlign.ObjectId;

                fStake.ACTIVEALIGN = objAlign;
                nameLayer          = string.Format("STAKE-{0}", objAlign.Name);
                Layer.manageLayers(nameLayer);
                idAlign.changeProp(nameLayer: nameLayer);

                fStake.HandleAlign = objAlign.Handle;
                fStake.objectID    = idAlign;

                fStake.NameStakeObject = objAlign.Name;

                if (objAlign.Name.Contains("WALL"))
                {
                    fStake.ClassObj = "WALL";
                }
                else
                {
                    fStake.ClassObj = "ALIGN";
                }

                switch (fStake.ClassObj)
                {
                case "ALIGN":

                    Stake_GetCardinals.getCardinals_Horizontal(idAlign, ref varPOI);

                    Stake_GetNestedObjects.getNestedPoints(idAlign, ref varPOI, fStake.XRefDbModelSpace, Path.GetFileName(xRefPath.ToString()));

                    Stake_GetCardinals.getCardinals_Vertical(idAlign, ref varPOI);

                    //        Call getNestedObjects(objAlign, varPOI)

                    Stake_GetCardinals.getCrossingAligns(idAlign, ref varPOI);

                    Stake_AddProfile.makeProfile(idAlign, varPOI, "STAKE", "ByLayout", false);

                    Stake_GetBC_EC.getBC_EC(idAlign, ref varPOI);

                    Stake_DuplicateStations.resolveDuplicateStations(ref varPOI);

                    Stake_UpdateProfile.updateProfile(idAlign, varPOI, "STAKE", false, "STAKE");
                    Stake_UpdateProfile.updateProfile(idAlign, (fStake.POI_PNTs), "STAKE", true, "PNTS");

                    ResultBuffer rb = xRef.getXRefsContainingTargetDwgName("GCAL");
                    if (rb == null)
                    {
                        Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("GCAL drawing not attached");
                        return;
                    }

                    TypedValue[]     tvs      = rb.AsArray();
                    string           nameXRef = tvs[0].Value.ToString();
                    BlockTableRecord ms       = xRef.getXRefBlockTableRecordMS(nameXRef);

                    //        If getNestedPoints(objAlign, varPOI, objXRefDbModelSpace, "GCAL") = False Then
                    //          Exit Sub
                    //        End If

                    Debug.Print("After getNestedPoints");
                    for (int i = 0; i < varPOI.Count; i++)
                    {
                        Debug.Print(varPOI[i].Station + "  " + varPOI[i].Desc0);
                    }

                    //    Call makeProfileINVERT(objAlign, varPOI)

                    fStake.POI_CALC = varPOI;
                    //#############################################################

                    ObjectId idTable = Stake_Table.makeTable(idAlign, varPOI);
                    Stake_Table.addTableData(idTable, varPOI);

                    break;

                case "WALL":

                    Stake_Wall.processWall(idAlign);

                    break;
                }
                break;

            default:
                break;
            }

            if (fStake.ClassObj != "BLDG")
            {
                TypedValue[] tvs = new TypedValue[2] {
                    new TypedValue(1001, "CLASS"), new TypedValue(1000, fStake.ClassObj)
                };
                idAlign.setXData(tvs, "CLASS");
            }
        }
示例#5
0
        processSewer(string nameLayer, ObjectId idPolyGuideline, BlockTableRecord ms, string nameXRef, ref List <POI> varPOI, out ObjectId idAlign)
        {
            List <Point3d> pnts3d    = idPolyGuideline.getCoordinates3dList();
            Alignment      align     = null;
            string         nameAlign = "";

            idAlign = ObjectId.Null;

            if (pnts3d.Count == 1)
            {
                DialogResult varResponse = System.Windows.Forms.MessageBox.Show("Single segment selected!!\n\n" + "Proceed with single segment?\n", "SINGLE SEGMENT SELECTED", MessageBoxButtons.YesNo);

                switch (varResponse)
                {
                case DialogResult.Yes:
                    nameAlign          = Align.getAlignName(nameLayer);
                    align              = Align.addAlignmentFromPoly(nameAlign, nameLayer, idPolyGuideline, "Standard", "Standard", true);
                    fStake.ACTIVEALIGN = align;
                    idAlign            = align.ObjectId;
                    fStake.objectID    = idAlign;
                    break;

                case DialogResult.No:
                    varResponse = System.Windows.Forms.MessageBox.Show("Create Alignment?\n", "CREATE ALIGNMENT", MessageBoxButtons.YesNo);

                    switch (varResponse)
                    {
                    case DialogResult.Yes:
                        Stake_Algn.createNewAlign(nameLayer);
                        idPolyGuideline.delete();
                        break;

                    case DialogResult.No:
                        idPolyGuideline.delete();
                        break;
                    }
                    break;
                }
            }
            else
            {
                nameAlign          = Align.getAlignName(nameLayer);
                align              = Align.addAlignmentFromPoly(nameAlign, nameLayer, idPolyGuideline, "Standard", "Standard", true);
                fStake.ACTIVEALIGN = align;
                idAlign            = align.ObjectId;
                fStake.objectID    = idAlign;
            }

            fStake.HandleAlign     = idAlign.getHandle();
            fStake.NameStakeObject = nameAlign;

            Stake_GetCardinals.getCardinals_Horizontal(idAlign, ref varPOI);

            Stake_GetNestedObjects.getNestedPoints(idAlign, ref varPOI, ms, nameXRef);

            Stake_GetCardinals.getCrossingAligns(idAlign, ref varPOI);

            fStake.POI_ORG = varPOI;

            Stake_GetCardinals.getCardinals_Vertical(idAlign, ref varPOI);

            Stake_AddProfile.makeProfile(idAlign, varPOI, "STAKE", "ByLayout", false);

            Stake_GetBC_EC.getBC_EC(idAlign, ref varPOI);

            Stake_DuplicateStations.resolveDuplicateStations(ref varPOI);

            Stake_UpdateProfile.updateProfile(idAlign, varPOI, "STAKE", false, "STAKE");

            Stake_UpdateProfile.updateProfile(idAlign, fStake.POI_PNTs, "STAKE", true, "PNTS");
        }
示例#6
0
        modifyStaking(List <POI> varpoi)
        {
            Alignment objAlign = fStake.ACTIVEALIGN;
            ObjectId  idAlign  = objAlign.ObjectId;

            List <POI> varPOIadd = new List <POI>();

            if (Stake_GetCardinals.userAddCrossingsFeatures(idAlign, ref varPOIadd))
            {
                switch (fStake.ClassObj)
                {
                case "WTR":
                    Stake_GetSurfaceElev.getSurfaceElevations(idAlign, ref varPOIadd);

                    break;

                case "ALIGN":
                case "SEWER":

                    Stake_GetSurfaceElev.getProfileElevations(idAlign, "STAKE", ref varPOIadd);

                    break;
                }

                for (int i = 0; i <= varPOIadd.Count; i++)
                {
                    varpoi.Add(varPOIadd[i]);
                }

                var sortSta = from s in varpoi
                              orderby s.Station ascending
                              select s;

                List <POI> poitmp = new List <POI>();
                foreach (var s in sortSta)
                {
                    poitmp.Add(s);
                }

                varpoi = poitmp;

                Stake_AddProfile.makeProfile(idAlign, varpoi, "STAKE", "ByLayout", true);

                switch (fStake.ClassObj)
                {
                case "ALIGN":
                case "SEWER":

                    Stake_UpdateProfile.updateProfile(idAlign, varpoi, "STAKE", false, "STAKE");

                    break;
                }

                List <AlgnData> algnData = fStake.algnData;
                AlgnData        aData    = new AlgnData();
                Table           objTable = null;
                for (int i = 1; i < algnData.Count; i++)
                {
                    aData = algnData[i];

                    if (aData.AlignHandle == objAlign.Handle)
                    {
                        objTable = (Table)aData.TableHandle.getEnt();
                        objTable.ObjectId.delete();
                        break;
                    }
                }

                ObjectId idTable = Stake_Table.makeTable(idAlign, varpoi, aData);
                Stake_Table.addTableData(idTable, varpoi);
            }
            return(varpoi);
        }
示例#7
0
        stakePoints(object varStaBeg = null, object varStaEnd = null, object varSide = null, object varBegNum = null)
        {
            string    strClass = fStake.ClassObj;
            Alignment objAlign = null;

            try
            {
                objAlign = fStake.ACTIVEALIGN;
            }
            catch (System.Exception)
            {
                if (Stake_Algn.selectAlignment(ObjectId.Null))
                {
                    objAlign = fStake.ACTIVEALIGN;
                }
                else
                {
                    return;
                }
            }

            ObjectId idAlign = objAlign.ObjectId;

            fStake.STAKE_LAYER = fStake.cboOffset.Text + "-OS-" + objAlign.Name;

            ObjectId idTable = Stake_Table.getTableId(idAlign);

            List <POI> varpoi = Stake_Table.resetPOI(idTable);

            fStake.POI_CALC = varpoi;

            fStake.objectID = objAlign.ObjectId;
            int intSide = 0;

            double dblStation = 0, dblOffset = 0;

            if ((varSide == null))
            {
                if (double.Parse(fStake.cboOffset.Text) != 0)
                {
                    PromptStatus ps;
                    Point3d      varPntPick = Pub.pnt3dO;
                    try
                    {
                        varPntPick = UserInput.getPoint("\nSelect side to place stake points: <ESC to Cancel>", out ps, osMode: 0);
                    }
                    catch (System.Exception)
                    {
                        return;

                        ;
                    }

                    idAlign.getAlignStaOffset(varPntPick, ref dblStation, ref dblOffset);
                    if (System.Math.Abs(dblOffset) > 10.0)
                    {
                        string       message     = string.Format("Point selected is more than 10' from Alignment: {0} Continue", objAlign.Name);
                        DialogResult varResponse = MessageBox.Show(message, "Confirm stakng target.", MessageBoxButtons.YesNo);

                        if (varResponse == DialogResult.No)
                        {
                            return;
                        }
                        else
                        {
                            if (dblOffset < 0)
                            {
                                intSide = -1;
                            }
                            else
                            {
                                intSide = 1;
                            }

                            fStake.Side = intSide;
                        }
                    }
                    else
                    {
                        if (dblOffset < 0)
                        {
                            intSide = -1;
                        }
                        else
                        {
                            intSide = 1;
                        }

                        fStake.Side = intSide;
                    }
                }
                else
                {
                    fStake.Side = 1;
                }
            }
            else
            {
                intSide = int.Parse(varSide.ToString());
            }

            dblOffset = double.Parse(fStake.cboOffset.Text);
            string strName = fStake.NameStakeObject;

            var sortSta = from p in varpoi                              //sort stations
                          orderby p.Station ascending
                          select p;

            List <POI> poiTmp = new List <POI>();

            foreach (var p in sortSta)
            {
                poiTmp.Add(p);
            }
            varpoi = poiTmp;

            double dblStaBeg = Math.roundDown3((objAlign.StartingStation));
            double dblStaEnd = Math.roundDown3((objAlign.EndingStation));

            List <POI> varPOI_TOF = null;
            List <POI> varPOI_TOW = null;

            Profile objProfile = null;

            switch (strClass)
            {
            case "WTR":

                objProfile = Prof.getProfile(idAlign, "CPNT");

                break;

            case "WALL":
                for (int i = 0; i < varpoi.Count; i++)
                {
                    if (varpoi[i].Desc0 == "TOF")
                    {
                        varPOI_TOF.Add(varpoi[i]);
                    }
                    else if (varpoi[i].Desc0 == "TOW")
                    {
                        varPOI_TOW.Add(varpoi[i]);
                    }
                }
                break;

            default:

                objProfile = Prof.getProfile(idAlign, "STAKE");

                break;
            }

            List <POI> varPOI_TMP = new List <POI>();

            if (strClass == "WALL")
            {
                Stake_GetStationing.getStationing(ref varPOI_TOF, dblStaBeg, dblStaEnd);
                Stake_GetStationing.getStationing(ref varPOI_TOW, dblStaBeg, dblStaEnd);
                for (int i = 0; i < varPOI_TOF.Count; i++)
                {
                    varPOI_TMP.Add(varPOI_TOF[i]);
                }

                for (int j = 0; j < varPOI_TOW.Count; j++)
                {
                    varPOI_TMP.Add(varPOI_TOW[j]);
                }

                varpoi = varPOI_TMP;
            }
            else
            {
                Stake_GetCardinals.checkBegAndEndDesc(idAlign, ref varpoi);
                Stake_GetStationing.getStationing(ref varpoi, dblStaBeg, dblStaEnd);
            }

            poiTmp = new List <POI>();
            foreach (var p in sortSta)             //sort stations
            {
                poiTmp.Add(p);
            }
            varpoi = poiTmp;

            uint lngPntNumBeg = Stake_Util.getBegPntNum();

            fStake.POI_STAKED = new List <POI>();
            List <POI> varPOI_STAKE = new List <POI>();

            if (strClass == "BLDG")
            {
                varPOI_STAKE = fStake.POI_STAKE;
            }
            else
            {
                if ((varStaBeg == null))
                {
                    varPOI_STAKE = varpoi;
                }
                else
                {
                    for (int i = 0; i < varpoi.Count; i++)
                    {
                        if (varpoi[i].Station >= double.Parse(varStaBeg.ToString()) && varpoi[i].Station <= double.Parse(varStaEnd.ToString()))
                        {
                            varPOI_STAKE.Add(varpoi[i]);
                        }
                    }
                }
            }

            for (int i = 0; i < varPOI_STAKE.Count; i++)
            {
                Debug.Print(varPOI_STAKE[i].Station + " " + varPOI_STAKE[i].Desc0);
            }
            POI     poi = new POI();
            double  dblElev = 0, dblEasting = 0, dblNorthing = 0;
            string  strDesc = "", strOffset = "";
            Point3d dblPnt = Pub.pnt3dO;

            for (int i = 0; i < varPOI_STAKE.Count; i++)
            {             //**********PROCESS varPOI_STAKE*********************
                if (varPOI_STAKE[i].DescX == "")
                {
                    poi             = varPOI_STAKE[i];
                    poi.DescX       = varPOI_STAKE[i].Desc0;
                    varPOI_STAKE[i] = poi;
                }

                switch (varPOI_STAKE[i].ClassObj)
                {
                case "WALL":

                    if (varPOI_STAKE[i].Desc0 == "TOW")
                    {
                        dblElev = varPOI_STAKE[i].ElevTOW;
                    }
                    else if (varPOI_STAKE[i].Desc0 == "TOF")
                    {
                        dblElev = varPOI_STAKE[i].ElevTOF;
                    }

                    switch (varPOI_STAKE[i].Desc0)
                    {
                    case "AP":

                        if (varPOI_STAKE[i].DescX.Contains("END"))
                        {
                            switch (intSide)
                            {
                            case 1:                                                    //right side

                                if (varPOI_STAKE[i].isRightHand)
                                {                                                         //counterclockwise
                                    doAnglePointOUT(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                }
                                else
                                {                                                         //clockwise
                                    doAnglePointIN(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                }

                                break;

                            case -1:                                                    //left side

                                if (varPOI_STAKE[i].isRightHand)
                                {                                                         //counterclockwise
                                    doAnglePointIN(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                }
                                else
                                {                                                         //clockwise
                                    doAnglePointOUT(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                }

                                break;
                            }
                        }

                        break;

                    case "BC":
                    case "EC":

                        doCurve(ref i, idAlign, objProfile, varPOI_STAKE, intSide, dblOffset, strName);

                        break;

                    default:

                        strDesc = varPOI_STAKE[i].DescX;
                        if (string.IsNullOrEmpty(strDesc))
                        {
                            strDesc = varPOI_STAKE[i].Desc0;
                        }

                        try
                        {
                            idAlign.getAlignPointLoc(varPOI_STAKE[i].Station, dblOffset * intSide, ref dblEasting, ref dblNorthing);
                        }
                        catch (System.Exception)
                        {
                            idAlign.getAlignPointLoc(varPOI_STAKE[i].Station - 0.01, dblOffset * intSide, ref dblEasting, ref dblNorthing);
                        }

                        dblPnt = new Point3d(dblEasting, dblNorthing, dblElev);

                        strOffset = dblOffset.ToString();
                        setOffsetPoint(dblPnt, strOffset, strName, strDesc, idAlign, varPOI_STAKE[i].Station);

                        break;
                    }

                    break;

                case "WTR":

                    dblElev = System.Math.Round(objProfile.ElevationAt(Math.roundDown3(varPOI_STAKE[i].Station)), 2);

                    switch (varPOI_STAKE[i].Desc0.Substring(0, 2))
                    {
                    case "TE":

                        if (varPOI_STAKE[i].Side == intSide)
                        {
                            set5x5(idAlign, dblElev, varPOI_STAKE[i].Station, dblOffset, intSide, strName, varPOI_STAKE[i].DescX);
                        }
                        else
                        {
                            idAlign.getAlignPointLoc(varPOI_STAKE[i].Station, dblOffset * intSide, ref dblEasting, ref dblNorthing);

                            dblPnt = new Point3d(dblEasting, dblNorthing, dblElev);

                            strOffset = dblOffset.ToString();

                            setOffsetPoint(dblPnt, strOffset, strName, varPOI_STAKE[i].DescX, idAlign, varPOI_STAKE[i].Station);
                        }

                        break;

                    case "AP":

                        switch (intSide)
                        {
                        case 1:
                            //right side

                            //counterclockwise
                            if (varPOI_STAKE[i].isRightHand)
                            {
                                doAnglePointOUT(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                //clockwise
                            }
                            else
                            {
                                doAnglePointIN(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                            }

                            break;

                        case -1:
                            //left side

                            //counterclockwise
                            if (varPOI_STAKE[i].isRightHand)
                            {
                                doAnglePointIN(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                //clockwise
                            }
                            else
                            {
                                doAnglePointOUT(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                            }

                            break;
                        }

                        break;

                    default:

                        idAlign.getAlignPointLoc(varPOI_STAKE[i].Station, dblOffset * intSide, ref dblEasting, ref dblNorthing);
                        dblPnt = new Point3d(dblEasting, dblNorthing, dblElev);

                        strOffset = dblOffset.ToString();

                        double dblCrossingInv = 0;
                        string strCrossingInv = "";
                        if (varPOI_STAKE[i].CrossAlign != "")
                        {
                            if (varPOI_STAKE[i].CrossAlignInv != 0)
                            {
                                dblCrossingInv = System.Math.Round(varPOI_STAKE[i].CrossAlignInv, 2);
                                strCrossingInv = string.Format("{0} INV.", dblCrossingInv);
                            }
                            else
                            {
                                strCrossingInv = "";
                            }

                            ASCIIEncoding ascii = new ASCIIEncoding();

                            string strAlignDesc = string.Format("{0}{1}%%C PIPE {2}", varPOI_STAKE[i].CrossAlignSize, ascii.GetString(new Byte[] { (Byte)34 }), strCrossingInv);

                            setOffsetPoint(dblPnt, strOffset, strName, strAlignDesc, idAlign, varPOI_STAKE[i].Station);
                        }
                        else
                        {
                            setOffsetPoint(dblPnt, strOffset, strName, varPOI_STAKE[i].DescX, idAlign, varPOI_STAKE[i].Station);

                            if (varPOI_STAKE[i].Type != "")
                            {
                                setOffsetPoint(dblPnt, strOffset, strName, varPOI_STAKE[i].Type, idAlign, varPOI_STAKE[i].Station, " INV=");
                            }
                        }

                        break;
                    }

                    break;

                case "CURB":
                case "FL":

                    dblElev = System.Math.Round(objProfile.ElevationAt(Math.roundDown3(varPOI_STAKE[i].Station)), 2);

                    switch (varPOI_STAKE[i].Desc0)
                    {
                    case "AP":

                        if (varPOI_STAKE[i].DescX.Contains("END"))
                        {
                            switch (intSide)
                            {
                            case 1:                                                    //right side

                                if (varPOI_STAKE[i].isRightHand)
                                {                                                         //counterclockwise
                                    doAnglePointOUT(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                }
                                else
                                {                                                         //clockwise
                                    doAnglePointIN(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                }

                                break;

                            case -1:                                                    //left side

                                if (varPOI_STAKE[i].isRightHand)
                                {                                                         //counterclockwise
                                    doAnglePointIN(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                }
                                else
                                {                                                         //clockwise
                                    doAnglePointOUT(idAlign, dblElev, varPOI_STAKE[i].Station, varPOI_STAKE[i].AngDelta, varPOI_STAKE[i].AngDir, varPOI_STAKE[i].DescX, strName, intSide, dblOffset);
                                }

                                break;
                            }
                        }

                        break;

                    case "BC":
                    case "EC":

                        doCurve(ref i, idAlign, objProfile, varPOI_STAKE, intSide, dblOffset, strName);

                        break;

                    default:

                        strDesc = varPOI_STAKE[i].DescX;
                        //          If strDesc = "" Then
                        //            strDesc = varPOI_Stake[i].Desc0
                        //          End If

                        try
                        {
                            idAlign.getAlignPointLoc(varPOI_STAKE[i].Station, dblOffset * intSide, ref dblEasting, ref dblNorthing);
                        }
                        catch (System.Exception)
                        {
                            idAlign.getAlignPointLoc(varPOI_STAKE[i].Station - 0.01, dblOffset * intSide, ref dblEasting, ref dblNorthing);
                        }
                        dblPnt = new Point3d(dblEasting, dblNorthing, dblElev);

                        strOffset = dblOffset.ToString();
                        setOffsetPoint(dblPnt, strOffset, strName, strDesc, idAlign, varPOI_STAKE[i].Station);

                        break;
                    }

                    break;

                case "ALIGN":
                case "SEWER":

                    dblElev = System.Math.Round(objProfile.ElevationAt(Math.roundDown3(varPOI_STAKE[i].Station)), 2);

                    if (varPOI_STAKE[i].Desc0 == "BC")
                    {
                        setRadiusPoint(idAlign, varPOI_STAKE[i], varPOI_STAKE[i].Radius, strName);
                    }

                    try
                    {
                        idAlign.getAlignPointLoc(varPOI_STAKE[i].Station, dblOffset * intSide, ref dblEasting, ref dblNorthing);
                    }
                    catch (System.Exception)
                    {
                    }

                    dblPnt = new Point3d(dblEasting, dblNorthing, dblElev);

                    strOffset = dblOffset.ToString();
                    setOffsetPoint(dblPnt, strOffset, strName, varPOI_STAKE[i].Desc0, idAlign, varPOI_STAKE[i].Station);

                    break;
                }
            }

            List <POI> varPOI_STAKED = fStake.POI_STAKED;
            int        intUBnd       = varPOI_STAKED.Count - 1;

            uint lngPntNumEnd = uint.Parse(varPOI_STAKED[intUBnd].PntNum);

            TypedValue[] tvs = new TypedValue[4] {
                new TypedValue(1001, "STAKE"),
                new TypedValue(1071, lngPntNumBeg),
                new TypedValue(1071, lngPntNumEnd),
                new TypedValue(1000, fStake.STAKE_LAYER)
            };

            idAlign.setXData(tvs, "STAKE");

            CgPnt_Group.updatePntGroup("SPNT");

            Stake_UpdateProfile.updateProfile(idAlign, (fStake.POI_STAKED), "STAKE", true, "STAKED");

            bool     exists = false;
            ObjectId idDict = Dict.getNamedDictionary("STAKE_PNTS", out exists);

            List <Point3d> dblPnts   = new List <Point3d>();
            Point3d        pnt3d     = Pub.pnt3dO;
            uint           lngPntNum = 0;

            for (int p = 0; p < varPOI_STAKED.Count; p++)
            {
                string varPntNum = varPOI_STAKED[p].PntNum;

                int intPos = varPntNum.IndexOf(" ");

                if (intPos != 0)
                {
                    lngPntNum = uint.Parse(varPntNum.Substring(0, intPos - 1));
                }
                else
                {
                    lngPntNum = uint.Parse(varPntNum);
                }

                ObjectId idPnt = BaseObjs._civDoc.CogoPoints.GetPointByPointNumber(uint.Parse(varPOI_STAKED[p].PntNum));
                pnt3d = idPnt.getCogoPntCoordinates();
                dblPnts.Add(pnt3d);
                ResultBuffer rb = new ResultBuffer {
                    new TypedValue(1000, idPnt.getCogoPntNumber().ToString()),
                    new TypedValue(1005, idPnt.getHandle().ToString())
                };
                Dict.addXRec(idDict, idPnt.ToString(), rb);
            }

            dblPnts.Add(dblPnts[0]);

            Misc.logUsage("STAKE", (lngPntNumEnd - lngPntNumBeg + 1));
        }