Exemple #1
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;
        }
Exemple #2
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");
        }
Exemple #3
0
        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");
            }
        }
Exemple #4
0
        changeAlignStartPoint()
        {
            //BEGIN: UPDATE PROFILE, TABLE, AND POIs

            AlgnData  algnData = new AlgnData();
            ObjectId  idAlign  = ObjectId.Null;
            Alignment objAlign = null;

            if (selectAlignment(idAlign))
            {
                objAlign = fStake.ACTIVEALIGN;
            }
            else
            {
                return;
            }

            objAlign = fStake.ACTIVEALIGN;
            AlignmentEntityCollection objAlignEnts = objAlign.Entities;

            //BEGIN: UPDATE PROFILE, TABLE, AND POIs
            double       dblLenAlign = objAlign.Length;
            PromptStatus ps;
            Point3d      varPnt = UserInput.getPoint("Select Desired Start Point", out ps, osMode: 0);

            double dblStation = 0, dblOffset = 0;

            idAlign.getAlignStaOffset(varPnt, ref dblStation, ref dblOffset);
            double dblStationStart = objAlign.StartingStation;
            double dblStationDelta = dblStation - dblStationStart;
            // if varPnt is out of range then dblStation returns ZERO

            Profile profFLOWLINE      = Prof.getProfile(idAlign, "FLOwLINE");
            ProfilePVICollection pvis = profFLOWLINE.PVIs;

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

            foreach (ProfilePVI pvi in pvis)
            {
                POI poi = new POI {
                    Station = Math.roundDown3(pvi.Station), Elevation = pvi.Elevation
                };
                varPOI_Temp.Add(poi);
            }

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

            //adjust POI_Temp stationing

            for (int i = 0; i < varPOI_Temp.Count; i++)
            {
                POI poi = varPOI_Temp[i];
                if (poi.Station < dblStationDelta + dblStationStart)
                {
                    poi.Station = Math.roundDown3(dblLenAlign + varPOI_Temp[i].Station);
                }
                else
                {
                    poi.Station = Math.roundDown3(varPOI_Temp[i].Station - dblStationDelta);
                }
                varPOI_Temp[i] = poi;
            }

            List <POI> poiTmp       = new List <POI>();
            var        sortPOI_Temp = from t in varPOI_Temp
                                      orderby t.Station ascending
                                      select t;

            foreach (var t in sortPOI_Temp)
            {
                poiTmp.Add(t);
            }
            varPOI_Temp = poiTmp;

            int k = varPOI_Temp.Count;

            POI poitemp = varPOI_Temp[k - 1];

            poitemp.Elevation = varPOI_Temp[0].Elevation;
            varPOI_Temp[k]    = poitemp;

            Debug.Print("varPOI_Temp After");
            for (int i = 0; i < k; i++)
            {
                Debug.Print(varPOI_Temp[i].Station + "  " + varPOI_Temp[i].Elevation);
            }

            //END: UPDATE PROFILE, TABLE, AND POIs

            ObjectId idPoly = objAlign.GetPolyline();
            Polyline poly   = (Polyline)idPoly.getEnt();

            string   strAlignName = objAlign.Name;
            AlgnData aData;

            for (int j = 1; j < fStake.algnData.Count; j++)
            {
                aData = fStake.algnData[j];
                if (aData.AlignHandle == objAlign.Handle)
                {
                    break;
                }
            }

            objAlign.ReferencePointStation = 100.0;

            foreach (AlignmentEntity ent in objAlignEnts)
            {
                objAlignEnts.Remove(ent);
            }

            List <Vertex2d> v2ds = Conv.poly_Vertex2dList(idPoly);

            int p = 0;

            foreach (Vertex2d v in v2ds)
            {
                if (v.Position.IsEqualTo(varPnt, new Tolerance(0, 0)))
                {
                    break;
                }
                p++;
            }

            List <Vertex2d> v2dsNew = new List <Vertex2d>();

            for (int i = p; i < v2ds.Count; i++)
            {
                v2dsNew.Add(v2ds[i]);
            }

            for (int i = 1; i < p; i++)
            {
                v2dsNew.Add(v2ds[i]);
            }
            v2dsNew.Add(v2ds[p]);

            int     lngID = 0;
            Point3d dblPntBeg = Pub.pnt3dO, dblPntEnd = Pub.pnt3dO, dblPntMid = Pub.pnt3dO;

            for (int i = 1; i < v2dsNew.Count; i++)
            {
                if (v2dsNew[i].Bulge == 0)
                {
                    dblPntBeg = v2dsNew[i - 1].Position;
                    dblPntEnd = v2dsNew[i = 0].Position;

                    AlignmentLine objAlignEntTan = objAlign.Entities.AddFixedLine(lngID, dblPntBeg, dblPntEnd);
                    lngID = objAlignEntTan.EntityId;
                }
                else
                {
                    dblPntBeg = v2dsNew[i - 1].Position;
                    dblPntEnd = v2dsNew[i = 0].Position;

                    int intDir = 0;

                    if (v2dsNew[i - 1].Bulge > 0)
                    {
                        intDir = 1;
                    }
                    else
                    {
                        intDir = -1;
                    }

                    Arc arc = (Arc)Arc.Create(IntPtr.Zero, true);
                    arc.StartPoint = dblPntBeg;
                    arc.EndPoint   = dblPntEnd;

                    Point3d pnt3dMidLC = dblPntBeg.getMidPoint3d(dblPntEnd);
                    double  lenLC      = dblPntBeg.getDistance(dblPntEnd);
                    double  dirLC      = dblPntBeg.getDirection(dblPntEnd);
                    double  lenM       = System.Math.Abs(lenLC / 2 * v2dsNew[i - 1].Bulge);
                    dblPntMid = pnt3dMidLC.traverse(dirLC + System.Math.PI / 2 * intDir, lenM);

                    AlignmentArc objAlignEntArc = objAlign.Entities.AddFixedCurve(lngID, dblPntBeg, dblPntMid, dblPntEnd);
                    lngID = objAlignEntArc.EntityId;
                }
            }

            objAlign.Update();
            objAlign.ReferencePoint        = varPnt.Convert2d(BaseObjs.xyPlane);
            objAlign.ReferencePointStation = System.Math.Round(100.0 + dblStationDelta, 3);

            //BEGIN: UPDATE PROFILE, TABLE, AND POIs
            List <POI> varpoi = fStake.POI_CALC;

            //POIs are updated when selectAlignment is executed

            //ADJUST POI STATIONING
            //need complete POIs for descriptions
            for (int i = 0; i < varpoi.Count; i++)
            {
                if (varpoi[i].Station < dblStationDelta + dblStationStart)
                {
                    varpoi[i].Station = Math.roundDown3(dblLenAlign + varpoi[i].Station);
                }
                else
                {
                    varpoi[i].Station = Math.roundDown3(varpoi[i].Station - dblStationDelta);
                }
            }

            varpoi = varpoi.sortPOIbyStation();

            int n = varpoi.Count;

            varpoi[0].DescX     = "BEG " + varpoi[0].Desc0;
            varpoi[n - 2].DescX = varpoi[n - 2].DescX.Replace("END", "").Trim();
            varpoi[n - 1].DescX = varpoi[n - 1].DescX.Replace("BEG", "END").Trim();

            if (fStake.ClassObj == "CURB")
            {
                Stake_AddProfile.makeProfile(idAlign, varPOI_Temp, "CURB", "ByLayout", true);
            }

            ObjectId idTable = Stake_Table.makeTable(idAlign, varpoi);

            Stake_Table.addTableData(idTable, varpoi);

            if (Stake_GetBC_EC.getBC_EC(idAlign, ref varpoi) == false)
            {
                return;
            }

            fStake.POI_CALC = varpoi;
            //END: UPDATE PROFILE, TABLE, AND POIs
        }
Exemple #5
0
        public static void reverseAlign(ObjectId idAlign)
        {
            List <POI>           varpoi      = null;
            List <POI>           varPOI_ORG  = null;
            List <POI>           varPOI_Temp = null;
            ProfilePVICollection objPVIs     = null;

            string nameLayer = idAlign.getLayer();

            TypedValue[] tvs = new TypedValue[9];
            tvs.SetValue(new TypedValue((int)DxfCode.Operator, "<OR"), 0);
            tvs.SetValue(new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Polyline)).DxfName), 1);
            tvs.SetValue(new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Leader)).DxfName), 2);
            tvs.SetValue(new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(DBText)).DxfName), 3);
            tvs.SetValue(new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(MText)).DxfName), 4);
            tvs.SetValue(new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Circle)).DxfName), 5);
            tvs.SetValue(new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Dimension)).DxfName), 6);
            tvs.SetValue(new TypedValue((int)DxfCode.Operator, "OR>"), 7);
            tvs.SetValue(new TypedValue((int)DxfCode.LayerName, nameLayer), 8);

            SelectionSet ss = Select.buildSSet(tvs);

            ObjectId[] ids = ss.GetObjectIds();
            foreach (ObjectId id in ids)
            {
                id.delete();
            }

            Alignment objAlign    = (Alignment)idAlign.getEnt();
            double    dblLenAlign = objAlign.Length;

            switch (fStake.ClassObj)
            {
            case "BLDG":
                Profile profCPNT = Prof.getProfile(idAlign, "CPNT");
                objPVIs = profCPNT.PVIs;
                break;

            case "CURB":
                Profile profFLOWLINE = Prof.getProfile(idAlign, "FLOWLINE");
                objPVIs = profFLOWLINE.PVIs;

                break;

            case "FL":

                profCPNT = Prof.getProfile(idAlign, "CPNT");
                objPVIs  = profCPNT.PVIs;

                break;

            case "SEWER":
            case "WTR":

                profCPNT = Prof.getProfile(idAlign, "CPNT");
                objPVIs  = profCPNT.PVIs;

                break;

            case "ALIGN":

                Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("Object is an existing design alignment - exiting");
                return;
            }

            int j = objPVIs.Count;

            for (int i = 0; i < j; i++)
            {
                varPOI_Temp[i].Station = Math.roundDown3(dblLenAlign - (objPVIs[i].Station - objAlign.StartingStation)) + objAlign.StartingStation;
                //starting station is always 100
                varPOI_Temp[i].Elevation = objPVIs[i].Elevation;
            }

            objAlign.Reverse();

            varpoi = fStake.POI_CALC;

            //reverse varPOI stationing
            //need all POIs for descriptions
            for (int i = 0; i < varpoi.Count; i++)
            {
                varpoi[i].Station = Math.roundDown3(dblLenAlign - (varpoi[i].Station - objAlign.StartingStation)) + objAlign.StartingStation;
                //starting station is always 100
                varpoi[i].Side = varpoi[i].Side * -1;

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

                    if (varpoi[i].isRightHand)
                    {
                        varpoi[i].AngDir = varpoi[i].AngDir + varpoi[i].AngDelta;
                    }
                    else
                    {
                        varpoi[i].AngDir = varpoi[i].AngDir - varpoi[i].AngDelta;
                    }

                    varpoi[i].isRightHand = !varpoi[i].isRightHand;

                    break;

                case "BC":

                    varpoi[i].Desc0 = "EC";
                    varpoi[i].DescX = varpoi[i].DescX.Replace("BC", "EC");

                    break;

                case "EC":

                    varpoi[i].Desc0 = "BC";
                    varpoi[i].DescX = varpoi[i].DescX.Replace("EC", "BC");

                    break;
                }
            }

            varPOI_ORG = fStake.POI_ORG;

            //reverse varPOI_ORG stationing
            //need all POIs for descriptions
            for (int i = 0; i < varPOI_ORG.Count; i++)
            {
                varPOI_ORG[i].Station = Math.roundDown3(dblLenAlign - (varPOI_ORG[i].Station - objAlign.StartingStation)) + objAlign.StartingStation;
                //starting station is always 100
            }
            List <POI> poiTmp = new List <POI>();

            var sortPOI = from p in varpoi
                          orderby p.Station ascending
                          select p;

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

            poiTmp = new List <POI>();
            var sortPOI_ORG = from n in varPOI_ORG
                              orderby n.Station ascending
                              select n;

            foreach (var n in sortPOI_ORG)
            {
                poiTmp.Add(n);
            }
            varPOI_ORG = poiTmp;

            poiTmp = new List <POI>();
            var sortPOI_Temp = from t in varPOI_Temp
                               orderby t.Station ascending
                               select t;

            foreach (var t in sortPOI_Temp)
            {
                poiTmp.Add(t);
            }
            varPOI_Temp = poiTmp;

            j = varpoi.Count;
            varpoi[0].DescX = varpoi[0].DescX.Replace("END", "BEG");
            varpoi[j].DescX = varpoi[j].DescX.Replace("BEG", "END");

            ObjectId idTable = Stake_Table.getTableId(idAlign);

            Stake_Table.addTableData(idTable, varpoi);

            fStake.POI_CALC = varpoi;
            fStake.POI_ORG  = varPOI_ORG;

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

                Stake_AddProfile.makeProfile(idAlign, varPOI_Temp, "STAKE", "ByLayout", true);
                Stake_UpdateProfile.updateProfile(idAlign, (fStake.POI_ORG), "STAKE", true, "STAKE");

                break;

            case "CURB":

                Stake_AddProfile.makeProfile(idAlign, varPOI_Temp, "CURB", "ByLayout", true);
                Stake_UpdateProfile.updateProfile(idAlign, (fStake.POI_ORG), "FLOWLINE", true, "ORG");

                break;

            case "FL":

                Stake_AddProfile.makeProfile(idAlign, varPOI_Temp, "FLOWLINE", "BySurface", true);
                Stake_UpdateProfile.updateProfile(idAlign, (fStake.POI_ORG), "STAKE", true, "ORG");

                break;

            case "WTR":

                Stake_AddProfile.makeProfile(idAlign, varPOI_Temp, "STAKE", "BySurface", true);
                Stake_UpdateProfile.updateProfile(idAlign, (fStake.POI_ORG), "CPNT", true, "ORG");
                Stake_UpdateProfile.updateProfile(idAlign, varpoi, "STAKE", false, "STAKE");

                break;
            }
        }
Exemple #6
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");
        }
Exemple #7
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);
        }