makeProfile(ObjectId idAlign)
{
Point3d pnt3dPick = Pub.pnt3dO;
if (idAlign == ObjectId.Null)
{
Autodesk.AutoCAD.DatabaseServices.Entity ent = Select.selectEntity(typeof(Alignment), "\nSelect Alignment: ", "\nSelected object was not an alignment. Try again: ", out pnt3dPick);
idAlign = ent.ObjectId;
}
bool exists = false;
ProfileView pView = null;
using (BaseObjs._acadDoc.LockDocument())
{
TinSurface tinSurf = Surf.getTinSurface("EXIST", out exists);
string nameProfile = tinSurf.Name;
Profile profEX = Prof.addProfileBySurface(nameProfile, idAlign, tinSurf.ObjectId, fMNP.idLayer, fMNP.idProfileStyleEX, fMNP.idProfileLabelSetEX);
tinSurf = Surf.getTinSurface("CPNT-ON", out exists);
nameProfile = tinSurf.Name;
Profile profDE = Prof.addProfileBySurface(nameProfile, idAlign, tinSurf.ObjectId, fMNP.idLayer, fMNP.idProfileStyleDE, fMNP.idProfileLabelSetDE);
fMNP.idProfile = profDE.ObjectId;
PromptStatus ps;
pnt3dPick = UserInput.getPoint("Select insertion point for Profile View", out ps, osMode: 0);
pView = Prof.addProfileView(idAlign, pnt3dPick, fMNP.idProfileBandSetStyle, fMNP.idProfileViewStyle);
}
return(pView.ObjectId);
}
deleteBreaklinesInSurface(string nameSurface)
{
bool exists = false;
TinSurface surf = Surf.getTinSurface(nameSurface, out exists);
if (exists)
{
surf.deleteBreaklines();
}
}
makeVolSurface(string strNameBASE, string strNameCOMP, bool boolShowMessage)
{
string nameSurface = string.Format("VOL_{0}_{1}", strNameBASE, strNameCOMP);
List <string> nameSurfaces = Surf.getSurfaces();
for (int i = 0; i < nameSurfaces.Count; i++)
{
if (nameSurfaces[i] == nameSurface)
{
Surf.removeSurface(nameSurfaces[i]);
}
}
TinSurface objSurfaceBASE = Surf.getTinSurface(strNameBASE);
TinSurface objSurfaceCOMP = Surf.getTinSurface(strNameCOMP);
int lngVolCut = 0;
int lngVolFill = 0;
ObjectId idSurfFill = TinVolumeSurface.Create(nameSurface, objSurfaceBASE.ObjectId, objSurfaceCOMP.ObjectId);
SelectionSet objSSetLim = EW_Utility1.buildSSetGradingLim();
ObjectId[] ids = objSSetLim.GetObjectIds();
TinVolumeSurface objSurfaceFILL = null;
if (ids != null && ids.Length > 0)
{
ObjectId idPoly = ids[0];
idPoly.checkIfClosed();
ObjectId idPoly3d = Conv.poly_Poly3d(idPoly, 0, "0");
ObjectId[] idBndrys = { idPoly3d };
objSurfaceFILL = (TinVolumeSurface)idSurfFill.getEnt();
objSurfaceFILL.BoundariesDefinition.AddBoundaries(new ObjectIdCollection(idBndrys), 1.0, Autodesk.Civil.SurfaceBoundaryType.Outer, true);
objSurfaceFILL.Rebuild();
idPoly3d.delete();
}
else
{
MessageBox.Show("GRADING LIMIT not found - OUTER BOUNDARY not added.");
}
lngVolCut = (int)objSurfaceFILL.GetVolumeProperties().UnadjustedCutVolume / 27;
lngVolFill = (int)objSurfaceFILL.GetVolumeProperties().UnadjustedFillVolume / 27;
if (boolShowMessage == true)
{
string mess = string.Format("Cut: {0} CY Fill: {1} CY", lngVolCut, lngVolFill);
MessageBox.Show(mess);
}
EW_Main.viewResults("VOL", false);
}
public static void processPoints(SelectionSet objSSet, List <Point3d> varPntsLeader)
{
winPadCerts wPadCerts = PC_Forms.pcForm.wPadCerts;
int k = varPntsLeader.Count;
List <double> dx = new List <double>();
List <double> dy = new List <double>();
for (int i = 1; i < k; i++)
{
dx.Add(varPntsLeader[i].X - varPntsLeader[i - 1].X);
dy.Add(varPntsLeader[i].Y - varPntsLeader[i - 1].Y);
}
double dblDir = varPntsLeader[k - 2].getDirection(varPntsLeader[k - 1]);
string strName = System.Convert.ToString(wPadCerts.lbxSurfaceName.SelectedItem);
TinSurface objSurface = Surf.getTinSurface(strName);
ObjectId[] ids = objSSet.GetObjectIds();
for (int i = 0; i < ids.Length; i++)
{
List <Point3d> pnts3dLdr = new List <Point3d>();
Point3d pnt3d = ids[i].getCogoPntCoordinates();
double dblElevPnt = pnt3d.Z;
pnts3dLdr.Add(new Point3d(pnt3d.X, pnt3d.Y, 0));
for (int j = 0; j < dx.Count; j++)
{
pnt3d = new Point3d(pnt3d.X + dx[j], pnt3d.Y + dy[j], 0);
pnts3dLdr.Add(pnt3d);
}
Point3d pnt3dInsTxt = pnt3d;
double dblElevSurface = objSurface.FindElevationAtXY(pnts3dLdr[0].X, pnts3dLdr[0].Y);
if (wPadCerts.optBase.IsChecked == true)
{
dblElevSurface = dblElevSurface + (System.Convert.ToDouble(wPadCerts.tbxPvmtThickness.Text)) / 12;
}
else if (wPadCerts.optSG.IsChecked == true)
{
dblElevSurface = dblElevSurface + (System.Convert.ToDouble(wPadCerts.tbxTotalSection.Text)) / 12;
}
PacCerts.PC_LblElevDiff.labelElevDiff(dblElevPnt, dblElevSurface, pnts3dLdr, pnt3dInsTxt, dblDir);
}
}
makeSurface(string strSurfaceName)
{
SelectionSet objSSet = EW_Utility1.buildSSet2a(strSurfaceName);
if (objSSet == null || objSSet.Count == 0)
{
return;
}
ObjectId[] ids = objSSet.GetObjectIds();
ObjectIdCollection idsBrks = new ObjectIdCollection();
foreach (ObjectId id in ids)
{
idsBrks.Add(id);
}
EW_CheckSurfaceStyles.checkSurfaceStyles(strSurfaceName);
TinSurface objSurface = Surf.getTinSurface(strSurfaceName);
if (objSurface == null)
{
return;
}
objSurface.ObjectId.delete();
objSurface = Surf.addTinSurface(strSurfaceName, out exists);
objSurface.BreaklinesDefinition.AddStandardBreaklines(idsBrks, 1.0, 0, 0, 0);
objSurface.BuildOptions.CrossingBreaklinesElevationOption = Autodesk.Civil.CrossingBreaklinesElevationType.UseAverage;
SelectionSet objSSetLim = EW_Utility1.buildSSetGradingLim();
if (objSSetLim.Count == 0)
{
MessageBox.Show("GRADING LIMIT not found - OUTER BOUNDARY not added.");
return;
}
ObjectId idLWPline = objSSetLim.GetObjectIds()[0];
Conv.processBndry(idLWPline);
ObjectId[] id3dPoly = { Conv.poly_Poly3d(idLWPline, 0, "0") };
objSurface.BoundariesDefinition.AddBoundaries(new ObjectIdCollection(id3dPoly), 1.0, Autodesk.Civil.SurfaceBoundaryType.Outer, true);
objSurface.Rebuild();
id3dPoly[0].delete();
}
makeBotSurfaceGrid(int intInterval, int i1)
{
App.SetSystemVariable("PDSISE", 0.01);
setPointStyleBOT();
setPointLabelStyleBOT();
bool exists;
TinSurface objSurfaceCPNT_ON = Surf.getTinSurface("CPNT-ON", out exists);
Object[] varLimits = EW_Utility2.getLimits(intInterval);
double dblPntXmin = (double)varLimits[0];
double dblPntYmin = (double)varLimits[1];
int iMax = (int)varLimits[2];
int jMax = (int)varLimits[3];
for (int j = 0; j <= jMax; j++)
{
double dblY = dblPntYmin + (j * intInterval);
for (int i = 0; i <= iMax; i++)
{
double dblX = dblPntXmin + (i * intInterval);
double dblZ_OX = objSurfaceCPNT_ON.FindElevationAtXY(dblX, dblY);
if (dblZ_OX > 0) //point is inside OX boundary
{
Point3d dblPnt = new Point3d(dblX, dblY, dblZ_OX);
ObjectId idCivilPnt = dblPnt.setPoint("GRID-POINTS");
}
}
}
TypedValue[] tvs = new TypedValue[4] {
new TypedValue(1001, "BOT"),
new TypedValue(1040, varLimits[0]),
new TypedValue(1040, varLimits[1]),
new TypedValue(1070, intInterval)
};
ObjectId idDictBOT = Dict.getNamedDictionary("BOT", out exists);
idDictBOT.setXData(tvs, "BOT");
return(varLimits);
}
modSurface(string nameSurface, string descSurface, ObjectIdCollection idsPoly3d, bool boolNewSurface)
{
bool exists = false;
TinSurface objSurface = Surf.getTinSurface(nameSurface, out exists);
if (!exists)
{
objSurface.StyleId = Surf_Styles.getSurfaceStyle(nameSurface);
}
objSurface.BreaklinesDefinition.AddStandardBreaklines(idsPoly3d, 1, 0, 0, 0);
objSurface.BuildOptions.CrossingBreaklinesElevationOption = Autodesk.Civil.CrossingBreaklinesElevationType.UseAverage;
objSurface.Rebuild();
}
checkBldgElev(string strAlignName)
{
TinSurface objSurface = null;
bool exists = false;
try
{
ObjectId idLayer = Layer.manageLayers(fStake.GCAL_LAYER);
BaseObjs.regen();
}
catch (System.Exception)
{
Stake_GetSurfaceCPNT.getSurfaceFromXRef("STAKE", "STAKE");
objSurface = Surf.getTinSurface("CPNT-ON", out exists);
}
Alignment objAlign = Align.getAlignment(strAlignName);
string.Format("\"Test Building No. {0} :\n", strAlignName);
Form.ControlCollection objCntrls = default(Form.ControlCollection);
Control objCntrl = default(Control);
if (checkBldgElevs(objAlign.ObjectId))
{
objCntrls = (Form.ControlCollection)fGrid.Frame08.Controls;
objCntrl = objCntrls[strAlignName];
objCntrl.BackgroundImage = System.Drawing.Image.FromFile("R:\\TSET\\VBA\\CHECK.bmp");
objCntrls = (Form.ControlCollection)fGrid.Frame10.Controls;
objCntrl = objCntrls[string.Format("cmd{0}", strAlignName.Substring(5))];
objCntrl.Enabled = true;
}
else
{
objCntrls = (Form.ControlCollection)fGrid.Frame08.Controls;
objCntrl = objCntrls[strAlignName];
objCntrl.BackgroundImage = System.Drawing.Image.FromFile("R:\\TSET\\VBA\\X.bmp");
objCntrls = (Form.ControlCollection)fGrid.Frame10.Controls;
objCntrl = objCntrls[string.Format("cmd{0}", strAlignName.Substring(5))];
objCntrl.Enabled = false;
}
}
updateVolSurface(string strNameBASE, string strNameCOMP)
{
string nameSurface = string.Format("VOL_{0}_{1}", strNameBASE, strNameCOMP);
List <string> nameSurfaces = Surf.getSurfaces();
for (int i = 0; i < nameSurfaces.Count; i++)
{
if (nameSurfaces[i] == nameSurface)
{
Surf.removeSurface(nameSurfaces[i]);
}
}
TinSurface objSurfaceBASE = Surf.getTinSurface(strNameBASE);
TinSurface objSurfaceCOMP = Surf.getTinSurface(strNameCOMP);
TinVolumeSurface.Create(nameSurface, objSurfaceBASE.ObjectId, objSurfaceCOMP.ObjectId);
}
makeRemSurface(double dblDepth)
{
EW_CheckSurfaceStyles.checkSurfaceStyles("EXIST");
Point3d pnt3dMove0 = Point3d.Origin;
Point3d pnt3dMoveX = new Point3d(0, 0, dblDepth * -1);
Matrix3d mtx3d = Matrix3d.Displacement(pnt3dMoveX - pnt3dMove0);
TinSurface objSurfaceExist = Surf.getTinSurface("EXIST");
ObjectId idSurface = objSurfaceExist.copy();
using (var tr = BaseObjs.startTransactionDb()) {
TinSurface surface = (TinSurface)tr.GetObject(idSurface, OpenMode.ForWrite);
surface.Name = "EG-ADJ2";
Layer.manageLayers("EG-ADJ2-SURFACE");
surface.Layer = "EG-ADJ2" + "-SURFACE";
surface.TransformBy(mtx3d);
surface.Rebuild();
}
}
public static void makeSurfaceSG()
{
//Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor.Command("_ucs", "w", "");
BaseObjs.sendCommand("_ucs\rw\r");
TinSurface objSurfaceCPNT = Surf.getTinSurface("CPNT-ON", out exists);
SelectionSet objSSet = null;
if (pub.boolDebug)
{
objSSet = EW_Utility1.buildSSet1(); //SelectOnScreen _XX-*
}
else
{
objSSet = EW_Utility1.buildSSet0(); //get _XX-*
}
if (objSSet == null || objSSet.Count == 0)
{
return;
}
ObjectId[] ids = objSSet.GetObjectIds();
timeBeg = DateTime.Now;
ObjectId idPolyT = ObjectId.Null;
for (int i = 0; i < ids.Length; i++)
{
Polyline objLWPline = (Polyline)ids[i].getEnt();
ObjectId idLWPlineT = objLWPline.copy();
if (idLWPlineT.IsNull)
{
MessageBox.Show("Null Id @ line 131 EW_Main");
continue;
}
idLWPlineT.changeProp(LineWeight.LineWeight050, clr.yel);
if (objLWPline.HasBulges)
{
idPolyT = Conv.processBndry(idLWPlineT); //boundary with arcs converted to line segments
idLWPlineT.delete();
}
else
{
Entity ent = idLWPlineT.getEnt();
idPolyT = ent.ObjectId;
}
//Entity entx = idPolyT.getEnt();
//MessageBox.Show(entx.GetType().ToString());
switch (objLWPline.Layer)
{
case "_XX-FLOOR SLAB_A":
case "_XX-FLOOR SLAB_B":
case "_XX-FLOOR SLAB_C":
case "_XX-DOCK APRON":
color = clr.yel;
break;
default:
color = clr.grn;
break;
}
ObjectId idLWPlineX = ObjectId.Null;
if (!objLWPline.Layer.Contains("_XX-FLOOR"))
{
idLWPlineX = idPolyT.offset(-0.05);
idPolyT.delete();
}
else
{
idLWPlineX = idPolyT;
}
if (idLWPlineX.IsNull)
{
MessageBox.Show("Null Id @ line 162 EW_Main" + idPolyT.getHandle().ToString());
continue;
}
idLWPlineX.changeProp(LineWeight.LineWeight060, color);
if (!offsetSegments("CPNT-ON", "SG", idLWPlineX, objLWPline.Layer))
{
return;
}
}
viewResults("SG", true);
}
public static void testBotElev(object[] varGridData, bool boolReTest)
{
bool boolProceed = false;
bool isOX = false;
bool isOXg = false;
double dblPntXmin = (double)(varGridData[0]);
double dblPntYmin = (double)(varGridData[1]);
int intInterval = (int)varGridData[2];
Layer.manageLayers("BOT-POINTS");
TinSurface objSurfaceSG = Surf.getTinSurface("SG");
if (objSurfaceSG == null)
{
MessageBox.Show("Surface SG is missing. Exiting ......");
return;
}
TinSurface objSurfaceOX = Surf.getTinSurface("OX");
if (objSurfaceOX == null)
{
MessageBox.Show("Surface OX is missing. Exiting ......");
}
TinSurface objSurfaceOXg = Surf.getTinSurface("OXg");
if (objSurfaceOXg != null)
{
isOXg = true;
}
EW_Utility1.getTableData();
TinSurface objSurfaceEXIST = null;
if (p.REMOVE_REPLACE_BLDG_V == -1)
{
objSurfaceEXIST = Surf.getTinSurface("NATIVE");
if (objSurfaceEXIST == null)
{
MessageBox.Show("NATIVE surface missing while Remove and Replace values are 0. Exiting routine..........");
return;
}
}
else
{
objSurfaceEXIST = Surf.getTinSurface("EXIST");
if (objSurfaceEXIST == null)
{
objSurfaceEXIST = Surf.getTinSurface("exist");
if (objSurfaceEXIST == null)
{
MessageBox.Show("Surface EXIST missing. Exiting routine......");
return;
}
}
}
SurfaceDefinitionBoundaries bndrys = objSurfaceEXIST.BoundariesDefinition;
for (int i = 0; i < bndrys.Count; i++)
{
if (bndrys[i].BoundaryType == Autodesk.Civil.SurfaceBoundaryType.Hide)
{
MessageBox.Show("Surface EXIST is using HIDE Boundaries - exiting program");
return;
}
}
try {
SelectionSet objSSet = null;
if (p.boolDebug)
{
objSSet = EW_Utility1.buildSSet2b("OX"); //GET "OX-BRKLINE* by select
}
else
{
if (isOX)
{
objSSet = EW_Utility1.buildSSet2a("OX"); //GET "OX-BRKLINE*
}
else
{
objSSet = EW_Utility1.buildSSet2a("SG"); //GET "SG-BRKLINE*
}
}
//BEGIN BOUNDARY EDIT - ADD X GRID POINTS
ObjectId[] ids = objSSet.GetObjectIds();
for (int i = 0; i < ids.Length; i++)
{
ObjectId id3dBndry_Org = ids[i];
if (p.boolDebug)
{
id3dBndry_Org.changeProp(LineWeight.LineWeight020, clr.c70);
}
ResultBuffer rb = id3dBndry_Org.getXData("makeBOT");
if (rb == null)
{
continue;
}
TypedValue[] tvs = rb.AsArray();
string strType = "";
try {
strType = tvs[2].Value.ToString();
}
catch (System.Exception) {
strType = "K-BRACE";
}
rb = id3dBndry_Org.getXData("OX");
if (rb == null)
{
continue;
}
tvs = rb.AsArray();
try {
string strSource = tvs[1].Value.ToString();
switch (strSource)
{
case "OX1":
strType = "OX1";
break;
case "OX2":
strType = "OX2";
break;
case "OX3":
strType = "OX3";
break;
case "OX4":
strType = "OX4";
break;
}
}
catch (System.Exception) {
}
List <Point3d> varPnts3dBndry = id3dBndry_Org.getCoordinates3dList();
int k = varPnts3dBndry.Count;
List <Point3d> dblPnts3dBndry = new List <Point3d>();
Point3d pnt3d = new Point3d(varPnts3dBndry[0].X, varPnts3dBndry[0].Y, 0.0);
dblPnts3dBndry.Add(pnt3d);
int intXCounter = 0, intYCounter = 0;
for (int j = 1; j < k; j++)
{
Point3d pnt3dBeg = varPnts3dBndry[j - 1];
Point3d pnt3dEnd = varPnts3dBndry[j - 0];
double dblLEN = pnt3dBeg.getDistance(pnt3dEnd);
if (dblLEN > 5)
{
double dblAngle = pnt3dBeg.getDirection(pnt3dEnd);
int intXbeg = (int)((pnt3dBeg.X - dblPntXmin) / intInterval);
int intXend = (int)((pnt3dEnd.X - dblPntXmin) / intInterval);
if (intXend - intXbeg > 0)
{
intXCounter = 1;
intXbeg++;
boolProceed = true;
}
else if (intXend - intXbeg < 0)
{
intXCounter = -1;
intXend++;
boolProceed = true;
}
else if (intXend - intXbeg == 0)
{
intXCounter = -1;
boolProceed = false;
}
if (boolProceed == true)
{
for (int n = intXbeg; n <= intXend; n += intXCounter)
{
double dblX = dblPntXmin + n * intInterval;
double dblY = pnt3dBeg.Y + (dblX - pnt3dBeg.X) * System.Math.Tan(dblAngle);
pnt3d = new Point3d(dblX, dblY, 0);
if (p.boolDebug)
{
Draw.addCircle(pnt3d, 1, "DEBUG-0", (short)3);
}
dblPnts3dBndry.Add(pnt3d);
}
}
pnt3d = new Point3d(pnt3dEnd.X, pnt3dEnd.Y, 0.0);
dblPnts3dBndry.Add(pnt3d);
if (p.boolDebug)
{
Draw.addCircle(pnt3d, 1, "DEBUG-0", (short)3);
}
}
else
{
pnt3d = new Point3d(pnt3dEnd.X, pnt3dEnd.Y, 0.0);
dblPnts3dBndry.Add(pnt3d);
if (p.boolDebug)
{
Draw.addCircle(pnt3d, 1, "DEBUG-0", (short)2);
}
}
}
//END BOUNDARY EDIT - ADD X GRID POINTS
varPnts3dBndry = dblPnts3dBndry;
k = varPnts3dBndry.Count;
//BEGIN BOUNDARY EDIT - ADD Y GRID POINTS
dblPnts3dBndry = new List <Point3d>();
dblPnts3dBndry.Add(varPnts3dBndry[0]); //keep first point
if (p.boolDebug)
{
Draw.addCircle(dblPnts3dBndry[0], 1, "DEBUG-0", (short)1);
}
for (int x = 0; x < k; x++)
{
Point3d pnt3dBeg = varPnts3dBndry[x - 1];
Point3d pnt3dEnd = varPnts3dBndry[x - 0];
double dblLEN = pnt3dBeg.getDistance(pnt3dEnd);
if (dblLEN > 5)
{
double dblAngle = pnt3dBeg.getDirection(pnt3dEnd);
int intYbeg = (int)((pnt3dBeg.Y - dblPntYmin) / intInterval);
int intYend = (int)((pnt3dEnd.Y - dblPntYmin) / intInterval);
if (intYend - intYbeg > 0)
{
intYCounter = (short)1;
intYbeg++;
boolProceed = true;
}
else if (intYend - intYbeg < 0)
{
intYCounter = (short)(-1);
intYend++;
boolProceed = true;
}
else if (intYend - intYbeg == ((short)0))
{
intYCounter = (short)(-1);
boolProceed = false;
}
if (boolProceed == true)
{
for (k = intYbeg; k <= intYend; k += intYCounter)
{
double dblY = dblPntYmin + k * intInterval;
double dblX = pnt3dBeg.X + (dblY - pnt3dBeg.Y) / System.Math.Tan(dblAngle);
pnt3d = new Point3d(dblX, dblY, 0.0);
if (p.boolDebug)
{
Draw.addCircle(pnt3d, 1, "DEBUG-0", (short)2);
}
dblPnts3dBndry.Add(pnt3d);
}
}
dblPnts3dBndry.Add(pnt3dEnd);
if (p.boolDebug)
{
Draw.addCircle(pnt3dEnd, 1, "DEBUG-0", (short)3);
}
}
else
{
dblPnts3dBndry.Add(pnt3dEnd);
if (p.boolDebug)
{
Draw.addCircle(pnt3dEnd, 1, "DEBUG-0", (short)2);
}
}
}
//END BOUNDARY EDIT - ADD Y GRID POINTS
//BEGIN REMOVE DUPLICATE POINTS
List <Point3d> dblPnts3dBndryRev = new List <Point3d>();
dblPnts3dBndryRev.Add(dblPnts3dBndry[0]);
for (int j = 1; j < dblPnts3dBndry.Count; j++)
{
if (System.Math.Round(dblPnts3dBndry[j - 1].X, 3) == System.Math.Round(dblPnts3dBndry[j - 0].X, 3) &&
System.Math.Round(dblPnts3dBndry[j - 1].Y, 3) == System.Math.Round(dblPnts3dBndry[j - 0].Y, 3))
{
//do nothing
}
else
{
dblPnts3dBndryRev.Add(dblPnts3dBndry[j]);
}
}
//END REMOVE DUPLICATE POINTS
//BEGIN TEST ELEVATION ON BOUNDARY
k = dblPnts3dBndryRev.Count;
if (k > 3)
{
for (int j = 0; j < k; j++)
{
pnt3d = dblPnts3dBndryRev[j];
double dblZ_EXIST = EW_Utility2.getSurfaceElev(pnt3d.X, pnt3d.Y, objSurfaceEXIST);
double dblZ_R_R = 0;
if (isOX)
{
dblZ_R_R = dblZ_EXIST - p.REMOVE_REPLACE_BLDG_V;
}
else
{
dblZ_R_R = dblZ_EXIST - p.REMOVE_REPLACE_V;
}
double dblZ_SG = EW_Utility2.getSurfaceElev(pnt3d.X, pnt3d.Y, objSurfaceSG);
double dblZ_OX = EW_Utility2.getSurfaceElev(pnt3d.X, pnt3d.Y, objSurfaceOX);
double dblZ_OXg = 0;
if (isOXg)
{
dblZ_OXg = EW_Utility2.getSurfaceElev(pnt3d.X, pnt3d.Y, objSurfaceOXg);
}
double dblZ_MIN = dblZ_R_R;
if (dblZ_SG < dblZ_MIN)
{
dblZ_MIN = dblZ_SG;
}
if (dblZ_OX < dblZ_MIN)
{
dblZ_MIN = dblZ_OX;
}
if (isOXg)
{
if (dblZ_OXg < dblZ_MIN)
{
dblZ_MIN = dblZ_OXg;
}
}
if (dblZ_MIN <= 0)
{
Draw.addCircle(pnt3d, 1, "DEBUG-0", (short)1);
pnt3d = pnt3d.addElevation(dblZ_R_R);
dblPnts3dBndryRev.Add(pnt3d);
}
else
{
pnt3d = pnt3d.addElevation(dblZ_MIN);
dblPnts3dBndryRev.Add(pnt3d);
}
}
ObjectId id3dBndry = Draw.addPoly3d(dblPnts3dBndryRev);
if (strType == "LIM" || strType == "K-BRACE")
{
id3dBndry.changeProp(clr.byl, "BOT-BRKLINE-AREA");
}
else if (strType == "BRKLINES")
{
id3dBndry.changeProp(clr.byl, "BOT-BRKLINE");
}
}
//END TEST ELEVATION ON BOUNDARY
//BEGIN TEST ELEVATION ON GRID POINTS
List <string> excludes = new List <string>()
{
"BRKLINES", "OX2", "OX3", "OX4"
};
if (excludes.Contains(strType))
{
continue;
}
else
{
k = dblPnts3dBndryRev.Count;
dblPnts3dBndryRev.RemoveAt(k - 1);
Point3dCollection varPnts3dBndryCol = new Point3dCollection();
foreach (Point3d pnt in dblPnts3dBndryRev)
{
pnt.addElevation(0.0);
varPnts3dBndryCol.Add(pnt);
}
varPnts3dBndry = dblPnts3dBndryRev;
SelectionSet objSSetX = EW_Utility1.buildSSet11(varPnts3dBndryCol); //select points by polygon crossing
ids = objSSetX.GetObjectIds();
if (strType == "_XX-BUILDING ADJACENT LANDSCAPING")
{
//do nothing i.e. do not assign point description "BOT"
}
else
{
for (int j = 0; j < ids.Length; j++)
{
pnt3d = ids[j].getCogoPntCoordinates();
if (pnt3d.isInside(dblPnts3dBndryRev))
{
double dblZ_EXIST = EW_Utility2.getSurfaceElev(pnt3d.X, pnt3d.Y, objSurfaceEXIST);
double dblZ_R_R = 0;
if (isOX)
{
dblZ_R_R = dblZ_EXIST - p.REMOVE_REPLACE_BLDG_V;
}
else
{
dblZ_R_R = dblZ_EXIST - p.REMOVE_REPLACE_V;
}
double dblZ_SG = EW_Utility2.getSurfaceElev(pnt3d.X, pnt3d.Y, objSurfaceSG);
double dblZ_OX = EW_Utility2.getSurfaceElev(pnt3d.X, pnt3d.Y, objSurfaceOX);
double dblZ_OXg = 0;
if (isOXg)
{
dblZ_OXg = EW_Utility2.getSurfaceElev(pnt3d.X, pnt3d.Y, objSurfaceOXg);
}
if (dblZ_OX < 0)
{
dblZ_OX = dblZ_SG;
}
double dblZ_MIN = dblZ_R_R;
if (dblZ_SG < dblZ_MIN)
{
dblZ_MIN = dblZ_SG;
}
if (dblZ_OX < dblZ_MIN)
{
dblZ_MIN = dblZ_OX;
}
if (isOXg)
{
if (dblZ_OXg < dblZ_MIN)
{
dblZ_MIN = dblZ_OXg;
}
}
using (var tr = BaseObjs.startTransactionDb()) {
CogoPoint cgPnt = (CogoPoint)tr.GetObject(ids[j], OpenMode.ForRead);
cgPnt.Elevation = dblZ_MIN;
cgPnt.RawDescription = "BOT";
cgPnt.Layer = "BOT-POINTS";
cgPnt.StyleId = CgPnts.getPntStyle("BOT").ObjectId;
cgPnt.LabelStyleId = CgPnts.getPntLabelStyle("BOT");
}
}
}
}
}
//END TEST ELEVATION ON GRID POINTS+``````````
}
if (boolReTest == false)
{
EW_Main.viewResults("BOT", false);
}
}
catch {
}
return;
}
initForm()
{
TinVolumeSurface objSurfaceTIN = Surf.getTinVolumeSurface("VOL_EXIST_BOT");
dblVOL_EXIST_BOT_CUT = objSurfaceTIN.GetVolumeProperties().UnadjustedCutVolume / 27;
dblVOL_EXIST_BOT_FILL = objSurfaceTIN.GetVolumeProperties().UnadjustedFillVolume / 27;
objSurfaceTIN = Surf.getTinVolumeSurface("VOL_BOT_SG");
dblVOL_BOT_SG_CUT = objSurfaceTIN.GetVolumeProperties().UnadjustedCutVolume / 27;
dblVOL_BOT_SG_FILL = objSurfaceTIN.GetVolumeProperties().UnadjustedFillVolume / 27;
TinSurface objSurfaceCPNT = Surf.getTinSurface("CPNT-ON");
TinSurface objSurfaceSG = Surf.getTinSurface("SG");
dblSG_MEAN_ELEV = System.Math.Round(objSurfaceSG.GetGeneralProperties().MeanElevation, 2);
dblVOL_CUT_TOT = dblVOL_EXIST_BOT_CUT + dblVOL_BOT_SG_CUT;
dblVOL_FILL_TOT = dblVOL_EXIST_BOT_FILL + dblVOL_BOT_SG_FILL;
dblVOL_CUT_SHRINK = dblVOL_CUT_TOT * dblSHRINKAGE_FACTOR * -1;
dblVOL_CUT_NET = dblVOL_CUT_TOT + dblVOL_CUT_ADJ_NET + dblVOL_CUT_SHRINK;
dblVOL_FILL_NET = dblVOL_FILL_TOT + dblVOL_FILL_ADJ_NET;
dblVOL_NET = dblVOL_CUT_NET - dblVOL_FILL_NET;
dblSITE_ADJUST = dblVOL_NET * 27 / dblAREA_SITE;
strDATE = DateTime.Today.ToShortDateString();
strUSER = System.Environment.UserName;
EW_Data varDataCurrent = new EW_Data();
varDataCurrent.ITERATION = "C";
varDataCurrent.DATE = strDATE;
varDataCurrent.USER = strUSER;
varDataCurrent.AREA_SITE = dblAREA_SITE;
varDataCurrent.SG_MEAN_ELEV = dblSG_MEAN_ELEV;
varDataCurrent.VOL_CUT_TOT = dblVOL_CUT_TOT;
varDataCurrent.VOL_FILL_ADJ_NET = dblVOL_CUT_ADJ_NET;
varDataCurrent.VOL_CUT_SHRINK = dblVOL_CUT_SHRINK;
varDataCurrent.VOL_CUT_NET = dblVOL_CUT_NET;
varDataCurrent.VOL_FILL_TOT = dblVOL_FILL_TOT;
varDataCurrent.VOL_FILL_ADJ_NET = dblVOL_FILL_ADJ_NET;
varDataCurrent.VOL_FILL_NET = dblVOL_FILL_NET;
varDataCurrent.VOL_NET = dblVOL_NET;
varDataCurrent.SITE_ADJUST = dblSITE_ADJUST;
//ObjectId idDictEW = Dict.getNamedDictionary("EARTHWORK", out exists);
//idDict.delete(); !!!!!!!!!!!!!!!!!!!!!!!****************************!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ObjectId idDictEW = Dict.getNamedDictionary("EARTHWORK", out exists);
if (!exists)
{
this.Title = "NEW EARTHWORK - COOL!!";
dblSG_MEAN_ELEV0 = dblSG_MEAN_ELEV;
this.AdjustSurfaceSG.Text = string.Format("{0:#0.00}", dblSG_MEAN_ELEV - dblSG_MEAN_ELEV0);
ewData.Add(varDataCurrent);
this.DG1.DataContext = ewData;
}
else
{
ewData = getDictData();
if (ewData.Count != 0)
{
dblSG_MEAN_ELEV0 = ewData[0].SG_MEAN_ELEV;
if (dblSG_MEAN_ELEV0 == 0)
{
dblSG_MEAN_ELEV0 = dblSG_MEAN_ELEV;
}
this.AdjustSurfaceSG.Text = string.Format("{0:#0.00}", dblSG_MEAN_ELEV - dblSG_MEAN_ELEV0);
}
else
{
dblSG_MEAN_ELEV0 = dblSG_MEAN_ELEV;
}
this.DG1.DataContext = ewData;
}
}
getBldgOX2(ObjectId idLWPline_LIM, int intBldgNo, string strOption, string strLayer)
{
bool exists;
TinSurface surf = Surf.getTinSurface("CPNT-ON", out exists);
TypedValue[] tvs = new TypedValue[3] {
new TypedValue(1001, "OX"),
new TypedValue(1000, intBldgNo),
new TypedValue(1000, "OX0")
};
Layer.manageLayers("OX-LIM-OUTER");
Layer.manageLayers("OX-AREAS-BLDG");
Layer.manageLayers("OX-AREAS-2d");
if (!idLWPline_LIM.isRightHand())
{
idLWPline_LIM.reversePolyX();
}
//BLDGOX0
Color color = Misc.getColorByBlock(7);
ObjectId idBldgOX0 = ObjectId.Null;
if (strOption == "MAKE")
{
Polyline objBldgOX0 = (Polyline)Misc.getBldgLimitsEW(idLWPline_LIM); //returns BldgOX0 2dPolyline
idBldgOX0 = objBldgOX0.ObjectId;
//outer limit of building footprint
idBldgOX0.changeProp(color, "OX-AREAS-BLDG", LineWeight.LineWeight020);
idBldgOX0.checkIfClosed();
if (!idBldgOX0.isRightHand())
{
idBldgOX0.reversePolyX();
}
idBldgOX0.setXData(tvs, "OX");
}
else if (strOption == "MADE")
{
idBldgOX0 = idLWPline_LIM.copy("OX-AREAS-BLDG"); //limit of building footprint already made
idBldgOX0.changeProp(color, "OX-AREAS-BLDG", LineWeight.LineWeight020);
idBldgOX0.checkIfClosed();
if (!idBldgOX0.isRightHand())
{
idBldgOX0.reversePolyX();
}
idBldgOX0.setXData(tvs, "OX");
}
//BLDGOX1
color = Misc.getColorByBlock(1);
ObjectId idBldgOX1 = idBldgOX0.offset(EW_Pub.OX_LIMIT_H); //BldgOX1 2dPolyline
idBldgOX1.changeProp(color, "OX-AREAS-BLDG", LineWeight.LineWeight020);
//BLDGOX2
color = Misc.getColorByBlock(2);
ObjectId idBldgOX2 = idBldgOX0.offset(EW_Pub.OX_LIMIT_H + 2); //BldgOX2 2dPolyline
idBldgOX2.changeProp(color, "OX-LIM-OUTER", LineWeight.LineWeight020);
SelectionSet objSSet = EW_Utility1.buildSSetGradingLim(); //GRADING LIMIT
ObjectId idGradingLim = objSSet.GetObjectIds()[0];
int intSide = 0;
if (idBldgOX1.isOutsideGradingLimit(idGradingLim))
{
if (!idGradingLim.isRightHand())
{
intSide = 1;
}
else
{
intSide = -1;
}
ObjectId idGradingLimOffset = idGradingLim.offset(0.2 * intSide);
color = Misc.getColorByBlock(4);
idGradingLimOffset.changeProp(LineWeight.LineWeight020, color);
idBldgOX1 = EW_ModAdjacentAreas.modAdjacentOX_Intersect(idBldgOX1, idGradingLimOffset);
//modified OX1 - portion was outside GRADING LIMIT
color = Misc.getColorByBlock(1);
idBldgOX1.changeProp(color, "OX-AREAS-BLDG", LineWeight.LineWeight020);
tvs[2] = new TypedValue(1000, "OX1");
idBldgOX1.setXData(tvs, "OX");
idGradingLimOffset = idGradingLim.offset(0.1 * intSide);
color = Misc.getColorByBlock(5);
idGradingLimOffset.changeProp(LineWeight.LineWeight020, color);
idBldgOX2 = EW_ModAdjacentAreas.modAdjacentOX_Intersect(idBldgOX2, idGradingLimOffset);
//modified OX2 - portion was outside GRADING LIMIT
color = Misc.getColorByBlock(2);
idBldgOX2.changeProp(color, "OX-LIM-OUTER", LineWeight.LineWeight020);
tvs[2] = new TypedValue(1000, "OX2");
idBldgOX2.setXData(tvs, "OX");
}
else if (idBldgOX2.isOutsideGradingLimit(idGradingLim))
{
if (!idGradingLim.isRightHand())
{
intSide = 1;
}
else
{
intSide = -1;
}
ObjectId idGradingLimOffset = idGradingLim.offset(0.1 * intSide);
color = Misc.getColorByBlock(4);
idGradingLimOffset.changeProp(LineWeight.LineWeight020, color);
idBldgOX2 = EW_ModAdjacentAreas.modAdjacentOX_Intersect(idBldgOX2, idGradingLimOffset);
//modified OX2 - portion was outside GRADING LIMIT
color = Misc.getColorByBlock(1);
idBldgOX2.changeProp(color, "OX-AREAS-BLDG", LineWeight.LineWeight020);
tvs[2] = new TypedValue(1000, "OX1");
idBldgOX1.setXData(tvs, "OX");
tvs[2] = new TypedValue(1000, "OX2");
idBldgOX2.setXData(tvs, "OX");
}
else
{
tvs[2] = new TypedValue(1000, "OX1");
idBldgOX1.setXData(tvs, "OX");
tvs[2] = new TypedValue(1000, "OX2");
idBldgOX2.setXData(tvs, "OX");
}
//BLDGOX3
ObjectId idBldgOX3 = ObjectId.Null;
if (strOption == "MAKE")
{
ObjectId idBldgOXT = getOX_PadLim(idLWPline_LIM, idBldgOX0);
//building footprint and outer limit of building footprint
idBldgOX3 = idBldgOXT.offset(-EW_Pub.FOOTING_LIMIT_IN_H);
color = Misc.getColorByBlock(3);
idBldgOX3.changeProp(color, "OX-AREAS-BLDG", LineWeight.LineWeight020);
idBldgOXT.delete();
tvs[2] = new TypedValue(1000, "OX3");
idBldgOX3.setXData(tvs, "OX");
}
else if (strOption == "MADE")
{
idBldgOX3 = idBldgOX0.offset(-EW_Pub.FOOTING_LIMIT_IN_H);
color = Misc.getColorByBlock(3);
idBldgOX3.changeProp(color, "OX-AREAS-BLDG", LineWeight.LineWeight020);
tvs[2] = new TypedValue(1000, "OX3");
idBldgOX3.setXData(tvs, "OX");
}
//BLDGOX4
ObjectId idBldgOX4 = idBldgOX3.offset(-2);
//BldgOX4 2dPolyline
color = Misc.getColorByBlock(4);
idBldgOX4.changeProp(color, "OX-AREAS-BLDG", LineWeight.LineWeight020);
tvs[2] = new TypedValue(1000, "OX4");
idBldgOX4.setXData(tvs, "OX");
ObjectId idLine = ObjectId.Null;
Handle h2d, h3d;
double dblSlope, dblAngBase, dblAngTest;
Point3d pnt3dCEN = Pub.pnt3dO, pnt3dTAR = Pub.pnt3dO, pnt3dX = Pub.pnt3dO;
ObjectId idDict = Dict.getNamedDictionary("GRADEDOCK", out exists);
if (!exists)
{
Point3d varPntCen = idLWPline_LIM.getCentroid();
// objLWPline_LIM.getXdata "BldgSlab", varXDataType, varXData
//
// Dim objBldgSlab As Polyline
// Set objBldgSlab = clsdwg.thisdrawing.HandleToObject(varXData(1))
// Dim varPntsLWPline As Variant
// varPntsLWPline = objBldgSlab.getCoordinates3d
// Dim varPnts3dPoly As Variant
// varPnts3dPoly = convert2dCoordsTo3dCoords(varPntsLWPline)
//
//
// Dim varVector As Vector
// varVector = getClosetAdjacentSegment(dPntCen, objBldgSlab)
// MsgBox ("Direction to nearest segment is: " & varVector.Dir & _
//' vbCr & _
//' "Distance to nearest segment is: " & varVector.Dist)
//
// If isInside(varPntCen, varPnts3dPoly) = False Then
// MsgBox "Calculated centroid location is outside limits of Building footprint"
// Exit Function
// End If
double elevCen = surf.FindElevationAtXY(varPntCen.X, varPntCen.Y);
//SURFACE = "CPNT-ON"
double dblAngTar = 0; int intMark = 0;
Geom.getEastWestBaseLineDir(idLWPline_LIM, ref dblAngTar, ref intMark);
Point3d dPntTAR = varPntCen.traverse(dblAngTar, 20);
double elevTar = surf.FindElevationAtXY(dPntTAR.X, dPntTAR.Y);
dblSlope = System.Math.Round((elevTar - varPntCen.Z) / 20, 4);
if (dblSlope == 0)
{
dPntTAR = varPntCen.traverse(dblAngTar + pi / 2, 20);
elevTar = surf.FindElevationAtXY(dPntTAR.X, dPntTAR.Y);
dblSlope = System.Math.Round((elevTar - varPntCen.Z) / 20, 4);
if (System.Math.Round(dblSlope, 3) == 0)
{
dPntTAR = varPntCen.traverse(dblAngTar - pi / 2, 20); //back to original orientation
elevTar = surf.FindElevationAtXY(dPntTAR.X, dPntTAR.Y);
}
}
else if (dblSlope < 0)
{
dblAngTar = dblAngTar + pi;
}
dblAngBase = varPntCen.getDirection(dPntTAR);
idLine = Draw.addLine(varPntCen, dPntTAR);
EW_Dict.updateDictGRADEDOCK(idLWPline_LIM.getHandle(), "0".stringToHandle(), dblSlope, varPntCen, dPntTAR); //obj3dPoly.handle not pertinent at earthwork stage
}
else
{
EW_Dict.retrieveDictGRADEDOCK(out h2d, out h3d, out dblSlope, out pnt3dCEN, out pnt3dTAR);
dblAngBase = pnt3dCEN.getDirection(pnt3dTAR);
double dblLenBase = pnt3dCEN.getDistance(pnt3dTAR);
Point3d varPntPolar = pnt3dCEN.traverse(dblAngBase, dblLenBase);
idLine = Draw.addLine(pnt3dCEN, varPntPolar);
}
List <Point3d> varPntInt = idLine.intersectWith(idBldgOX0, extend.source);
if (varPntInt.Count > 0)
{
for (int i = 0; i < varPntInt.Count; i++)
{
pnt3dX = varPntInt[i];
dblAngTest = pnt3dCEN.getDirection(pnt3dX);
if (System.Math.Round(dblAngTest, 4) == System.Math.Round(dblAngBase, 4))
{
idLine = Draw.addLine(pnt3dCEN, pnt3dX);
pnt3dTAR = new Point3d(pnt3dX.X, pnt3dX.Y, pnt3dCEN.Z + pnt3dCEN.getDistance(pnt3dTAR) * dblSlope);
}
}
}
double elev = surf.FindElevationAtXY(pnt3dCEN.X, pnt3dCEN.Y);
pnt3dCEN = new Point3d(pnt3dCEN.X, pnt3dCEN.Y, elev);
double dblOffOX = EW_Pub.OUTER_FOOTINGS_V + EW_Utility1.getDepth(strLayer, "OX");
color = Misc.getColorByLayer();
//OX1
ObjectId id3dPoly = EW_Build3dPoly.build3dPoly(idBldgOX1, pnt3dCEN, pnt3dTAR, dblSlope, "OX", "OX-BRKLINE", "OX1", dblOffOX, 20);
id3dPoly.changeProp(LineWeight.LineWeight050, color);
varPntInt = idLine.intersectWith(idBldgOX2, extend.source);
idLine.delete();
if (varPntInt.Count > 2)
{
for (int i = 0; i < varPntInt.Count; i++)
{
pnt3dX = varPntInt[i];
dblAngTest = pnt3dCEN.getDirection(pnt3dX);
if (System.Math.Round(dblAngTest, 4) == System.Math.Round(dblAngBase, 4))
{
idLine = Draw.addLine(pnt3dCEN, pnt3dX);
pnt3dTAR = pnt3dTAR.addElevation(pnt3dCEN.Z + pnt3dCEN.getDistance(pnt3dX) * dblSlope);
idLine.delete();
break;
}
}
}
dblOffOX = EW_Pub.OUTER_FOOTINGS_V + EW_Utility1.getDepth(strLayer, "OX");
//OX3
id3dPoly = EW_Build3dPoly.build3dPoly(idBldgOX3, pnt3dCEN, pnt3dTAR, dblSlope, "OX", "OX-BRKLINE", "OX3", dblOffOX);
id3dPoly.changeProp(LineWeight.LineWeight050, color);
dblOffOX = EW_Pub.COLUMN_FOOTINGS_V + EW_Utility1.getDepth(strLayer, "OX");
//OX4
id3dPoly = EW_Build3dPoly.build3dPoly(idBldgOX4, pnt3dCEN, pnt3dTAR, dblSlope, "OX", "OX-BRKLINE", "OX4", dblOffOX);
id3dPoly.changeProp(LineWeight.LineWeight050, color);
Point3dCollection pnts3d = idBldgOX0.poly_pnt3dColl();
objSSet = EW_Utility1.buildSSet17(pnts3d); //get K BRACE areas
ObjectId[] ids = objSSet.GetObjectIds();
color = Misc.getColorByBlock(7);
//BEGIN K BRACE
for (int i = 0; i < ids.Length; i++)
{
ObjectId idBrace = ids[i];
idBrace = idBrace.offset(5.0);
idBrace.changeProp(LineWeight.LineWeight030, color);
dblOffOX = EW_Pub.K_BRACE_V + EW_Utility1.getDepth(strLayer, "OX");
id3dPoly = EW_Build3dPoly.build3dPoly(idBrace, pnt3dCEN, pnt3dTAR, dblSlope, "OX", "OX-BRKLINE", "OTHER", dblOffOX);
id3dPoly.changeProp(color, "OX-BRKLINE");
//bottom of K-Brace overexcavation
dblOffOX = EW_Pub.COLUMN_FOOTINGS_V + EW_Utility1.getDepth(strLayer, "OX");
color = Misc.getColorByBlock(5);
idBrace = idBrace.offset(0.2);
idBrace.changeProp(color);
List <Point3d> pnts3dBrace = idBrace.getCoordinates3dList();
List <Point3d> pnts3dNew = new List <Point3d>();
for (int j = 0; j < pnts3dBrace.Count; j++)
{
Point3d pnt3dBEG = pnts3dBrace[i + 0];
Point3d pnt3dEND = pnts3dBrace[i + 1];
double dblAng = pnt3dBEG.getDirection(pnt3dEND);
//angle of each segment
double angDiff = System.Math.Round(dblAngBase - dblAng, 2);
if (angDiff == 0)
{
pnt3dX = pnt3dBEG.traverse(dblAng - pi / 2, (EW_Pub.K_BRACE_V - dblOffOX) * 5.0);
pnts3dNew.Add(pnt3dX);
}
else if (angDiff == System.Math.Round(pi / 2, 2) || angDiff == System.Math.Round(3 * pi / 2, 2))
{
pnt3dX = pnt3dBEG.traverse(dblAng + pi, (EW_Pub.K_BRACE_V - dblOffOX) * 5.0);
pnts3dNew.Add(pnt3dX);
}
else if (angDiff == System.Math.Round(-1 * pi / 2, 2) || angDiff == System.Math.Round(-3 * pi / 2, 2))
{
pnt3dX = pnt3dBEG.traverse(dblAng - pi, (EW_Pub.K_BRACE_V - dblOffOX) * 5.0);
pnts3dNew.Add(pnt3dX);
}
else if (angDiff == System.Math.Round(1 * pi, 2) || angDiff == System.Math.Round(3 * pi, 2))
{
pnt3dX = pnt3dBEG.traverse(dblAng + pi / 2, (EW_Pub.K_BRACE_V - dblOffOX) * 5.0);
pnts3dNew.Add(pnt3dX);
}
else if (angDiff == System.Math.Round(-1 * pi, 2) || angDiff == System.Math.Round(-3 * pi, 2))
{
pnt3dX = pnt3dBEG.traverse(dblAng - pi / 2, (EW_Pub.K_BRACE_V - dblOffOX) * 5.0);
pnts3dNew.Add(pnt3dX);
}
//Call addCircle(dPntPolar, 2, 1)
}
pnts3dNew.Add(pnts3dNew[0]);
ObjectId idPoly = Draw.addPoly(pnts3dNew);
idPoly.checkIfClosed3d();
id3dPoly = EW_Build3dPoly.build3dPoly(id3dPoly, pnt3dCEN, pnt3dTAR, dblSlope, "OX", "OX-BRKLINE", "OTHER", dblOffOX);
id3dPoly.changeProp(color, "OX-BRKLINE");
idPoly.delete();
}
//END K BRACE
return(idBldgOX2);
}
public static void getTriangleSegs(string strSurfaceName)
{
DateTime timeStart = DateTime.Now;
string nameLayer = "";
if (strSurfaceName == "CPNT-ON")
{
nameLayer = "CPNT";
}
nameLayer = string.Format("{0}-BRKLINE", nameLayer);
Layer.manageLayers(nameLayer);
TinSurface objSurface = Surf.getTinSurface(strSurfaceName);
if (objSurface == null)
{
Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("CPNT-ON surface is not present - Needs data shortcut. Exiting......");
return;
}
List <EdgePnt> ePnts = new List <EdgePnt>();
TinSurfaceVertexCollection vertices = objSurface.Vertices;
foreach (TinSurfaceVertex v in vertices)
{
TinSurfaceEdgeCollection edges = v.Edges;
foreach (TinSurfaceEdge e in edges)
{
EdgePnt ePnt = new EdgePnt {
p1 = e.Vertex1.Location, p2 = e.Vertex2.Location
};
ePnts.Add(ePnt);
}
}
fProgressBar = new frmProgressBar();
fProgressBar.Show();
int k = ePnts.Count;
long lngOnePercent = (int)System.Math.Truncate(k / 100.0);
string strStatus = null;
List <int> lngMark = new List <int>();
for (int i = 0; i < k - 1; i++)
{
EdgePnt ePnt1 = ePnts[i];
for (int j = i + 1; j < k; j++)
{
EdgePnt ePnt2 = ePnts[j];
if (ePnt1.p1.isEqual(ePnt2.p2, 0.1))
{
if (ePnt1.p2.isEqual(ePnt2.p1, 0.1))
{
lngMark.Add(j);
break;
}
}
}
if (i % lngOnePercent == 0)
{
strStatus = "Comparing " + i + " of " + k / 2 + " Objects";
fProgressBar.ProgressBar1.Increment(1);
fProgressBar.Text = strStatus;
}
}
fProgressBar.ProgressBar1.Value = 0;
k = lngMark.Count;
lngOnePercent = (int)System.Math.Truncate(k / 100.0);
List <Point3d> pnts3dList = new List <Point3d>();
using (BaseObjs._acadDoc.LockDocument())
{
for (int i = 0; i < k; i++)
{
pnts3dList = new List <Point3d>()
{
ePnts[lngMark[i]].p1, ePnts[lngMark[i]].p2
};
ObjectId id3dPoly = Draw.addPoly3d(pnts3dList);
id3dPoly.changeProp(nameLayer: nameLayer);
if (i % lngOnePercent == 0)
{
strStatus = "Importing " + i + " of " + k + " Breaklines";
fProgressBar.ProgressBar1.Increment(1);
fProgressBar.Text = strStatus;
}
}
}
fProgressBar.Dispose();
fProgressBar = null;
DateTime timeEnd = DateTime.Now;
string mess = string.Format("Elapsed Time: {0}", (timeEnd - timeStart).ToString());
MessageBox.Show(mess);
}
CreateProfileBySurface(string strName, ObjectId idAlign, double dblAlignOffset)
{
string strAlignName = Align.getAlignName(idAlign);
//Dim idProfileStyle As ObjectId = Prof_Style.getProfileStyle("WALL")
//Dim idStyleLabelSet As ObjectId = Prof_Style.getProfileLabelSetStyle("WALL")
ObjectId idProfileStyle = Prof_Style.getProfileStyle("Standard");
ObjectId idStyleLabelSet = Prof_Style.getProfileLabelSetStyle("Standard");
string strLayerName = string.Format("PROFILE-{0}", strAlignName);
Alignment objAlignOff = null;
if (dblAlignOffset != 0)
{
ObjectId idPoly = Align.getAlignmentPoly(idAlign);
ObjectId idPolyOff = Base_Tools45.Draw.addPolyOffset(idPoly, dblAlignOffset);
strAlignName = string.Format("{0}_{1}_OFF", strAlignName, dblAlignOffset);
objAlignOff = Align.addAlignmentFromPoly(strAlignName, strLayerName, idPolyOff, "Thienes_Proposed", "Thienes_Proposed", true);
}
string strSurface = "";
if (strName == "CPNT")
{
strSurface = "CPNT-ON";
}
else
{
strSurface = strName;
}
TinSurface objSurface = null;
try
{
bool exists = false;
objSurface = Surf.getTinSurface(strSurface, out exists);
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
System.Windows.Forms.MessageBox.Show(strSurface + " is not available.");
}
Profile objProfile = null;
if (dblAlignOffset != 0)
{
Prof.removeProfile(objAlignOff.ObjectId, strName);
}
else
{
Prof.removeProfile(idAlign, strName);
}
ObjectId idStyle = default(ObjectId);
ObjectId idLabel = default(ObjectId);
using (BaseObjs._acadDoc.LockDocument())
{
using (Transaction TR = BaseObjs.startTransactionDb())
{
ObjectId idSurf = objSurface.ObjectId;
ObjectId idLayer = Layer.manageLayers(strLayerName);
string mess = string.Format("WALL,{0},{1},{2},{3},{4}", idAlign, idSurf, idLayer, idStyle, idLabel);
BaseObjs.write(mess);
try
{
objProfile = Prof.addProfileBySurface(strName, idAlign, idSurf, idLayer, idProfileStyle, idStyleLabelSet);
objProfile.Layer = strLayerName;
}
catch (Autodesk.AutoCAD.Runtime.Exception exp)
{
Autodesk.AutoCAD.ApplicationServices.Core.Application.ShowAlertDialog(exp.Message);
}
TR.Commit();
}
}
if (dblAlignOffset != 0)
{
ProfilePVI objPvi = null;
List <PNT_DATA> varPnt_Data = new List <PNT_DATA>();
PNT_DATA vPnt_Data = new PNT_DATA();
for (int i = 0; i <= objProfile.PVIs.Count; i++)
{
objPvi = objProfile.PVIs[i];
vPnt_Data.STA = objPvi.Station;
vPnt_Data.z = objPvi.Elevation;
vPnt_Data.OFFSET = dblAlignOffset;
varPnt_Data.Add(vPnt_Data);
}
fWall1.PNTSDESIGN = varPnt_Data;
return(objAlignOff.ObjectId);
}
return(idAlign);
}
SG(double B1Width, double B1Slope,
double B2Width, double B2Slope,
double slope, int interval,
string surfTAR, string surfDES,
int side = 0,
double elev = 0.0,
Polyline3d poly3d = null)
{
Boolean success = false;
Boolean doFirst = true;
Boolean doB1 = fSG.boolB1;
Boolean doB2 = fSG.boolB1;
List <Point3d> pnts3d = new List <Point3d>();
List <Point3d> pnts3dB1 = new List <Point3d>();
List <Point3d> pnts3dB2 = new List <Point3d>();
List <Point3d> pnts3dDL = new List <Point3d>();
List <Point3d> pnts3dRF = new List <Point3d>();
Point3d pnt3dA, pnt3dB, pnt3dC;
BaseObjs.acadActivate();
ObjectId idPoly3d = ObjectId.Null;
if (poly3d == null)
{
idPoly3d = Select.getBrkLine("\nSelect 3D Polyline Reference: ");
}
else
{
idPoly3d = poly3d.ObjectId;
}
List <SEG_PROP> segProps = new List <SEG_PROP>();
bool isClosed = idPoly3d.checkIfClosed3d(false);
Point3d pnt3dB1_Mb = Pub.pnt3dO, pnt3dB2_Mb = Pub.pnt3dO, pnt3dDL_Mb = Pub.pnt3dO, pnt3dRF_Mb = Pub.pnt3dO;
try
{
if (idPoly3d != ObjectId.Null)
{
pnts3d = idPoly3d.getCoordinates3dList();
segProps = pnts3d.getPoly3dSegProps();
if (side == 0)
{
side = Geom.getSide(pnts3d);
}
int k = pnts3d.Count;
switch (k)
{
case 2:
pnt3dA = pnts3d[0];
pnt3dB = pnts3d[1];
success = setupSlope(side, pnt3dA, pnt3dB, slope, ref doFirst, surfTAR, surfDES,
ref pnts3dB1, ref pnts3dB2, ref pnts3dDL, ref pnts3dRF,
B1Width, B2Width, B1Slope, B2Slope, doB1, doB2, interval, elev);
break;
default:
for (int i = 0; i < k - 1; i++)
{
if (i == 0)
{
pnt3dA = pnts3d[k - 2]; //second from last point
pnt3dB = pnts3d[k - 1]; //last point = first point
pnt3dC = pnts3d[1]; //second point
doMidDelta(side, pnt3dA, pnt3dB, pnt3dC, doB1, B1Width, B1Slope, doB2, B2Width, B2Slope,
surfTAR, elev, slope, ref pnt3dB1_Mb, ref pnt3dB2_Mb, ref pnt3dDL_Mb);
pnt3dA = pnts3d[i + 0];
pnt3dB = pnts3d[i + 1];
pnt3dC = pnts3d[i + 2];
doMidDelta(side, pnt3dA, pnt3dB, pnt3dC, doB1, B1Width, B1Slope, doB2, B2Width, B2Slope,
surfTAR, elev, slope, ref pnt3dB1_Mb, ref pnt3dB2_Mb, ref pnt3dDL_Mb);
}
else if (i < k - 2)
{
pnt3dA = pnts3d[i + 0];
pnt3dB = pnts3d[i + 1];
pnt3dC = pnts3d[i + 2];
doMidDelta(side, pnt3dA, pnt3dB, pnt3dC, doB1, B1Width, B1Slope, doB2, B2Width, B2Slope,
surfTAR, elev, slope, ref pnt3dB1_Mb, ref pnt3dB2_Mb, ref pnt3dDL_Mb);
}
else
{
pnt3dA = pnts3d[i + 0];
pnt3dB = pnts3d[i + 1];
pnt3dC = pnts3d[i + 2];
}
}
break;
}
}
}
catch (SystemException ex)
{
BaseObjs.writeDebug(ex.Message + " cmdSG.cs: line: 129");
success = false;
}
ObjectId idPoly3dX = ObjectId.Null;
ObjectIdCollection idsPoly3dX = new ObjectIdCollection();
TypedValue[] tvs = new TypedValue[13];
tvs.SetValue(new TypedValue(1001, "lnkSLP"), 0);
using (BaseObjs._acadDoc.LockDocument())
{
try
{
idPoly3d.updateBrkLine(pnts3dRF); //Grading reference line
Handle hB1;
if (pnts3dB1.Count > 0)
{
idPoly3dX = pnts3dB1.addPoly3d("CPNT-BRKLINE"); //Lower Bench
idsPoly3dX.Add(idPoly3dX);
hB1 = idPoly3dX.getHandle();
}
else
{
B1Width = 0.0;
B1Slope = 0.0;
hB1 = "0".stringToHandle();
}
tvs.SetValue(new TypedValue(1000, B1Width), 1);
tvs.SetValue(new TypedValue(1000, B1Slope), 2);
tvs.SetValue(new TypedValue(1005, hB1), 3);
Handle hB2;
if (pnts3dB2.Count > 0)
{
idPoly3dX = pnts3dB2.addPoly3d("CPNT-BRKLINE"); //Top of Slope/Upper Bench
idsPoly3dX.Add(idPoly3dX);
hB2 = idPoly3dX.getHandle();
}
else
{
B2Width = 0.0;
B2Slope = 0.0;
hB2 = "0".stringToHandle();
}
tvs.SetValue(new TypedValue(1000, B2Width), 4);
tvs.SetValue(new TypedValue(1000, B2Slope), 5);
tvs.SetValue(new TypedValue(1005, hB2), 6);
Handle hDL;
idPoly3dX = pnts3dDL.addPoly3d("CPNT-BRKLINE"); //Top of Slope/Daylight (in no upper bench)
idsPoly3dX.Add(idPoly3dX);
hDL = idPoly3dX.getHandle();
tvs.SetValue(new TypedValue(1000, slope), 7);
tvs.SetValue(new TypedValue(1070, side), 8);
tvs.SetValue(new TypedValue(1000, interval), 9);
tvs.SetValue(new TypedValue(1005, hDL), 10);
tvs.SetValue(new TypedValue(1000, surfTAR), 11);
tvs.SetValue(new TypedValue(1000, surfDES), 12);
idPoly3d.setXData(tvs, apps.lnkSLP);
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " cmdSG.cs: line: 192");
}
}
bool exists = false;
if (idPoly3dX != ObjectId.Null)
{
DialogResult result;
result = MessageBox.Show(string.Format("Add Slope Breaklines to Design Surface? \nYes to add to surface: {0}\nNo to keep Breaklines, but not add to surface.\nCancel to dispose of Breaklines.", surfDES),
"Slope Breaklines",
System.Windows.Forms.MessageBoxButtons.YesNoCancel);
switch (result)
{
case DialogResult.Yes:
TinSurface surf = Surf.getTinSurface(surfDES, out exists);
surf.BreaklinesDefinition.AddStandardBreaklines(idsPoly3dX, 1.0, 1.0, 0.0, 0.0);
success = true;
break;
case DialogResult.No:
success = true;
break;
case DialogResult.Cancel:
success = false;
break;
}
}
else
{
success = false;
}
return(success);
}
setBldgElevRef(Alignment objAlign)
{
TinSurface objSurface = null;
bool exists = false;
try
{
objSurface = Surf.getTinSurface("CPNT-ON", out exists);
if (!exists)
{
Stake_GetSurfaceCPNT.getSurfaceFromXRef("STAKE", "STAKE");
objSurface = Surf.getTinSurface("CPNT-ON", out exists);
}
}
catch (System.Exception)
{
}
ObjectId idBldg = objAlign.GetPolyline();
Point3d pnt3d = idBldg.getCentroid();
Point3d pnt3dCen = new Point3d(pnt3d.X, pnt3d.Y, objSurface.FindElevationAtXY(pnt3d.X, pnt3d.Y));
if (pnt3dCen.Z == -99999.99)
{
Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("Invalid Elevation at Reference Point - Exiting.......");
return;
}
//Set objCircle = addcircle(pnt3dCEN, 3)
//objCircle.color = acRed
//objCircle.Update
double dblAngTar = 0;
int intMark = 0;
idBldg.getEastWestBaseLineDir(ref dblAngTar, ref intMark);
Point3d pnt3dTar = new Point3d(pnt3d.X, pnt3d.Y, objSurface.FindElevationAtXY(pnt3d.X, pnt3d.Y));
double dblSlope = System.Math.Round((pnt3dTar.Z - pnt3dCen.Z) / 100, 4);
//Set objCircle = addcircle(pnt3dTAR, 3)
//objCircle.color = acYellow
//objCircle.Update
if (dblSlope == 0)
{
dblAngTar = dblAngTar + PI / 2;
if (dblAngTar > 2 * PI)
{
dblAngTar = dblAngTar - 2 * PI;
}
pnt3d = pnt3dCen.traverse(dblAngTar, 100);
pnt3dTar = new Point3d(pnt3d.X, pnt3d.Y, objSurface.FindElevationAtXY(pnt3d.X, pnt3d.Y));
// Set objCircle = addcircle(pnt3dTAR, 3)
// objCircle.color = acGreen
// objCircle.Update
if (System.Math.Round(dblSlope, 3) == 0)
{
pnt3d = pnt3dCen.traverse(dblAngTar - PI / 2, 100);
//back to original orientation
pnt3dTar = new Point3d(pnt3d.X, pnt3d.Y, objSurface.FindElevationAtXY(pnt3d.X, pnt3d.Y));
// Set objCircle = addcircle(pnt3dTAR, 3)
// objCircle.color = acCyan
// objCircle.Update
}
}
else if (dblSlope < 0)
{
dblAngTar = dblAngTar + PI;
if (dblAngTar > 2 * PI)
{
dblAngTar = dblAngTar - 2 * PI;
}
pnt3dTar = new Point3d(pnt3d.X, pnt3d.Y, objSurface.FindElevationAtXY(pnt3d.X, pnt3d.Y));
// Set objCircle = addcircle(pnt3dTAR, 3)
// objCircle.color = acBlue
// objCircle.Update
dblSlope = -dblSlope;
}
BlockReference objBlkRef = null;
using (Transaction tr = BaseObjs.startTransactionDb())
{
try
{
List <string> attVals = new List <string> {
dblSlope.ToString()
};
objBlkRef = Blocks.addBlockRef("G:\\TOOLBOX\\Slparrow_STAKE.dwg", pnt3dCen, dblAngTar, attVals);
objBlkRef.Layer = string.Format("STAKE-BLDG-{0}-LABEL", objAlign.Name);
}
catch (System.Exception)
{
}
tr.Commit();
}
idBldg.delete();
TypedValue[] tvs = new TypedValue[6] {
new TypedValue(1001, "BLDG"),
new TypedValue(1040, pnt3dCen.X),
new TypedValue(1040, pnt3dCen.Y),
new TypedValue(1040, pnt3dCen.Z),
new TypedValue(1040, dblAngTar),
new TypedValue(1040, dblSlope)
};
objAlign.ObjectId.setXData(tvs, "STAKE");
}
Create_Align_Profile_By3dPoly2a(Alignment objAlignPL, string strName, string strNameAlign, ObjectId idLayer, ObjectId idPoly3dRF)
{
ObjectId idAlign = ObjectId.Null;
ObjectId idProfileStyle = Prof_Style.getProfileStyle("WALL");
ObjectId idStyleLabelSet = Prof_Style.getProfileLabelSetStyle("WALL");
//ObjectId idProfileStyle = Prof_Style.getProfileStyle("Standard");
//ObjectId idStyleLabelSet = Prof_Style.getProfileLabelSetStyle("Standard");
bool boolBeg = false;
bool boolEnd = false;
ObjectId idPolyRF = ObjectId.Null;
Point3d pnt3dBegREF = Pub.pnt3dO, pnt3dEndREF = Pub.pnt3dO, pnt3dBegPL = Pub.pnt3dO, pnt3dEndPL = Pub.pnt3dO;
double dblStaBegRef = 0, dblOffBegRef = 0;
if (objAlignPL.Entities.Count > 1)
{
MessageBox.Show("Program is set up for ONE simple tangent alignment. Exiting.....");
return(idAlign);
}
else
{
List <Point3d> pnt3dsPoly3d = idPoly3dRF.getCoordinates3dList();
idPolyRF = idPoly3dRF.toPolyline(idPoly3dRF.getLayer());
pnt3dBegREF = idPolyRF.getBegPnt();
pnt3dEndREF = idPolyRF.getEndPnt();
pnt3dBegPL = objAlignPL.StartPoint;
pnt3dEndPL = objAlignPL.EndPoint;
double dblAngle = Measure.getAzRadians(pnt3dBegPL, pnt3dEndPL);
double dblDistBeg = Geom.getPerpDistToLine(pnt3dBegPL, pnt3dEndPL, pnt3dBegREF);
double dblDistEnd = Geom.getPerpDistToLine(pnt3dBegPL, pnt3dEndPL, pnt3dEndREF);
if (dblDistBeg > dblDistEnd)
{
using (BaseObjs._acadDoc.LockDocument()) {
idPolyRF.reversePolyX();
}
pnt3dBegREF = idPolyRF.getBegPnt();
pnt3dEndREF = idPolyRF.getEndPnt();
dblDistBeg = Geom.getPerpDistToLine(pnt3dBegPL, pnt3dEndPL, pnt3dBegREF);
dblDistEnd = Geom.getPerpDistToLine(pnt3dBegPL, pnt3dEndPL, pnt3dEndREF);
}
if (dblDistBeg < 0)
{
boolBeg = true;
pnt3dBegPL = Geom.traverse_pnt3d(pnt3dBegPL, dblAngle - PI, dblDistBeg * -1 + 10);
}
if (dblDistEnd > objAlignPL.Length + 10)
{
boolEnd = true;
pnt3dEndPL = Geom.traverse_pnt3d(pnt3dEndPL, dblAngle, objAlignPL.Length - dblDistEnd + 10);
}
string strlayer = objAlignPL.Layer;
ObjectId idPolyPL = ObjectId.Null;
if (boolBeg | boolEnd)
{
string strAlignName = objAlignPL.Name.ToString();
idLayer = Layer.manageLayers(strlayer);
using (BaseObjs._acadDoc.LockDocument()) {
using (Transaction TR = BaseObjs.startTransactionDb()) {
Align.removeAlignment(strAlignName);
objAlignPL = null;
List <Point3d> pnt3dColl = new List <Point3d>();
pnt3dColl.Add(pnt3dBegPL);
pnt3dColl.Add(pnt3dEndPL);
idPolyPL = Base_Tools45.Draw.addPoly(pnt3dColl, strlayer);
try {
objAlignPL = Align.addAlignmentFromPoly(strAlignName, strlayer, idPolyPL, "Thienes_Proposed", "Thienes_Proposed", true);
} catch (Autodesk.AutoCAD.Runtime.Exception) {
objAlignPL = Align.addAlignmentFromPoly(strAlignName, strlayer, idPolyPL, "Standard", "Standard", true);
}
objAlignPL.ReferencePointStation = 1000.0;
try {
objAlignPL.StationOffset(pnt3dBegREF.X, pnt3dBegREF.Y, ref dblStaBegRef, ref dblOffBegRef);
} catch (Autodesk.Civil.PointNotOnEntityException) {
dblStaBegRef = 0.0;
}
double easting = 0, northing = 0;
objAlignPL.PointLocation(dblStaBegRef, 0.0, ref easting, ref northing);
Point2d pnt2dRef = new Point2d(easting, northing);
objAlignPL.ReferencePoint = pnt2dRef;
fWall4.AlignPL = objAlignPL;
bool exists = false;
TinSurface objSurfaceEXIST = Surf.getTinSurface("EXIST", out exists);
ObjectId idAlignStyle = Align_Style.getAlignmentStyle("Standard");
ObjectId idAlignStyleSet = Align_Style.getAlignmentLabelSetStyle("Standard");
try {
Prof.removeProfile(objAlignPL.ObjectId, "EXIST");
} catch (Autodesk.AutoCAD.Runtime.Exception) {
}
idAlign = objAlignPL.ObjectId;
ObjectId idSurf = objSurfaceEXIST.ObjectId;
try {
Prof.addProfileBySurface("EXIST", idAlign, idSurf, idLayer, idProfileStyle, idStyleLabelSet);
} catch (Autodesk.AutoCAD.Runtime.Exception exp) {
Autodesk.AutoCAD.ApplicationServices.Core.Application.ShowAlertDialog(exp.ToString());
}
TR.Commit();
}
}
}
Alignment objAlignRF = null;
try {
objAlignRF = Align.addAlignmentFromPoly(strNameAlign, strlayer, idPolyRF, "Thienes_Proposed", "Thienes_Proposed", true);
} catch (Autodesk.AutoCAD.Runtime.Exception) {
objAlignRF = Align.addAlignmentFromPoly(strNameAlign, strlayer, idPolyRF, "Standard", "Standard", true);
}
double dblStation = 0;
double dblOffset = 0;
try {
objAlignRF.StationOffset(pnt3dsPoly3d[0].X, pnt3dsPoly3d[0].Y, ref dblStation, ref dblOffset);
} catch (Autodesk.Civil.PointNotOnEntityException) {
dblStation = 0.0;
}
if (dblStation != objAlignRF.StartingStation)
{
using (BaseObjs._acadDoc.LockDocument()) {
idPoly3dRF.reversePolyX();
}
pnt3dsPoly3d = idPoly3dRF.getCoordinates3dList();
}
try {
objAlignPL.StationOffset(pnt3dBegREF.X, pnt3dBegREF.Y, ref dblStaBegRef, ref dblOffBegRef);
} catch (Autodesk.Civil.PointNotOnEntityException) {
dblStaBegRef = 0.0;
}
objAlignRF.ReferencePointStation = dblStaBegRef;
Profile objProfile = null;
using (BaseObjs._acadDoc.LockDocument()) {
using (Transaction TR = BaseObjs.startTransactionDb()) {
idAlign = objAlignRF.ObjectId;
try {
objProfile = Prof.addProfileByLayout(strName, idAlign, idLayer, idProfileStyle, idStyleLabelSet);
} catch (Autodesk.AutoCAD.Runtime.Exception exp) {
Autodesk.AutoCAD.ApplicationServices.Core.Application.ShowAlertDialog(exp.ToString());
}
double dblElev = 0;
for (int i = 0; i <= pnt3dsPoly3d.Count - 1; i++)
{
try {
objAlignRF.StationOffset(pnt3dsPoly3d[i].X, pnt3dsPoly3d[i].Y, ref dblStation, ref dblOffset);
} catch (Autodesk.Civil.PointNotOnEntityException) {
dblStation = 0.0;
}
dblElev = pnt3dsPoly3d[i].Z;
if (System.Math.Abs(dblStation - objAlignRF.StartingStation) < 1.0)
{
dblStation = Base_Tools45.Math.roundUP2(dblStation);
}
if (System.Math.Abs(dblStation - objAlignRF.EndingStation) < 1.0)
{
dblStation = Base_Tools45.Math.roundDown2(dblStation);
}
objProfile.PVIs.AddPVI(dblStation, dblElev);
}
TR.Commit();
}
}
}
return(idAlign);
}
RDR()
{
string prompt, result;
bool escape = false, exists = false, done = false, done2 = false;
double trianglationFactor = 0.001; //applied to treads to avoid vertical faces0
double lenTread, lenLand, grdLandU, wthRiser;
List <riserSum> rSum = new List <riserSum>();
ResultBuffer rb;
TypedValue[] tvs;
Dict.deleteDictionary("RDR");
ObjectId idDict = Dict.getNamedDictionary("RDR", out exists);
if (exists)
{
rb = Dict.getXRec(idDict, "Defaults");
tvs = rb.AsArray();
lenTread = double.Parse(tvs[0].Value.ToString());
lenLand = double.Parse(tvs[1].Value.ToString());
grdLandU = double.Parse(tvs[2].Value.ToString());
wthRiser = double.Parse(tvs[4].Value.ToString());
}
else
{
lenTread = 11.0;
lenLand = 5.5;
grdLandU = -0.01;
wthRiser = 5.5;
}
do
{
prompt = string.Format("\nLength riser tread(LR): {0}; Width of Riser(W): {1}; Length upper landing(LL): {2}; Grade upper Landing(G): {3}; No Change <OK> [LR/W/LL/G/OK]", lenTread, wthRiser, lenLand, grdLandU);
escape = UserInput.getUserInputKeyword("OK", out result, prompt, "LR W LL G OK");
if (escape)
{
return;
}
switch (result)
{
case "LR":
UserInput.getUserInput("Enter Riser trEAD LENGTH in Inches ", out lenTread, lenTread);
break;
case "LL":
UserInput.getUserInput("Enter LENGTH of UPPER LANDING", out lenLand, lenLand);
break;
case "G":
UserInput.getUserInput("Enter SLOPE of UPPER Landing from HIGH POINT towards LOW POINT: ", out grdLandU, grdLandU);
break;
case "W":
UserInput.getUserInput("Enter RISER WIDTH: ", out wthRiser, wthRiser);
break;
case "OK":
done = true;
break;
}
}while (!done);
tvs = new TypedValue[5];
tvs.SetValue(new TypedValue(1000, lenTread), 0); //length of riser tread in inches
tvs.SetValue(new TypedValue(1000, lenLand), 1); //length of upper landing - perp to bldg
tvs.SetValue(new TypedValue(1000, grdLandU), 2); //grade of upper landing
tvs.SetValue(new TypedValue(1000, wthRiser), 4); //width of riser tread in inches
Dict.addXRec(idDict, "Defaults", new ResultBuffer(tvs));
object osMode = SnapMode.getOSnap();
SnapMode.setOSnap((int)osModes.NON);
TinSurface surf = Surf.getTinSurface("CPNT-ON", out exists);
Point3d pnt3dPick;
PromptStatus ps;
Entity ent = Select.selectEntity(typeof(Polyline3d), "\nSelect Building Floor Slab Breakline", "Selected entity was not a 3d Breakline", out pnt3dPick, out ps);
if (ps != PromptStatus.OK)
{
return;
}
Polyline3d poly3dFF = (Polyline3d)ent; //Finish Floor breakline
ent = Select.selectEntity(typeof(Polyline3d), "\nSelect Dock Apron Breakline adjacent to Building", "Selected entity was not a 3d Breakline", out pnt3dPick, out ps);
if (ps != PromptStatus.OK)
{
return;
}
Polyline3d poly3dDK = (Polyline3d)ent; //Dock brkline
List <Point3d> pnts3dDK = poly3dDK.ObjectId.getCoordinates3dList();
SnapMode.setOSnap((int)osModes.END);
Point3d pnt3dR0 = UserInput.getPnt3d(Pub.pnt3dO, "\nSelect Riser connect point: upper RH corner of upper Landing: ", osMode: 1);
Point3d pnt3dL0 = UserInput.getPnt3d(Pub.pnt3dO, "\nSelect Riser connect point: upper LH corner of upper Landing: ", osMode: 1);
Point3d pnt3dR, pnt3dL;
List <Point3d> pnts3dFF = poly3dFF.ObjectId.getCoordinates3dList();
List <Point3d> pnts3dSeg = new List <Point3d>();
int x = 0;
if (pnts3dFF.Count > 2)
{
x = Geom.getVertexNo(pnts3dFF, pnt3dR0);
pnts3dSeg.Add(pnts3dFF[x]);
pnts3dSeg.Add(pnts3dFF[x + 1]);
}
else
{
pnts3dSeg = pnts3dFF;
}
double dirSegFF = pnts3dSeg[0].getDirection(pnts3dSeg[1]);
double dirRiser = pnt3dR0.getDirection(pnt3dL0);
double dirPick = 0.0;
double testRight = Geom.testRight(pnts3dSeg[0], pnts3dSeg[1], pnt3dR0);
double angle0 = 0.0;
Point3d pnt3dTar = Pub.pnt3dO;
if (testRight > 0)
{
pnt3dTar = pnt3dR0.traverse(dirSegFF - pi / 2, 10.0);
angle0 = dirSegFF + pi / 2;
}
else
{
pnt3dTar = pnt3dR0.traverse(dirSegFF + pi / 2, 10.0);
angle0 = dirSegFF - pi / 2;
}
List <Point3d> pnts3dRay = new List <Point3d> {
pnt3dR0,
pnt3dTar
};
List <Point3d> pnts3dInt = pnts3dRay.intersectWith(pnts3dSeg, false, 0);
Point3d pnt3dRef = Pub.pnt3dO;
if (pnts3dInt.Count > 0)
{
pnt3dRef = pnts3dInt[0];
}
double slope = (pnts3dSeg[1].Z - pnts3dSeg[0].Z) / pnts3dSeg[0].getDistance(pnts3dSeg[1]);
double dirDiff = System.Math.Round(dirSegFF - dirRiser, 3);
double slopeRiser = 0.0;
if (dirDiff == 0)
{
slopeRiser = slope;
}
else
{
slopeRiser = -slope;
}
double dist0 = pnts3dSeg[0].getDistance(pnt3dRef);
double distTest = Geom.getPerpDistToLine(pnts3dSeg[0], pnts3dSeg[1], pnt3dR0);
Vector3d v3d = new Vector3d(sMath.Cos(dirSegFF), sMath.Sin(dirSegFF), slope);
Point3d pnt3dRBase = pnt3dR0;
Point3d pnt3dRff, pnt3dLff;
ObjectId idCgPnt = ObjectId.Null;
ObjectId idPoly3d = ObjectId.Null;
uint pntNum = 0;
int numRisers = 1;
double distBetween = 0.0;
bool single = false;
prompt = "\nMode <Single/Multiple> [S/M]";
result = string.Empty;
escape = UserInput.getUserInputKeyword("S", out result, prompt, "S M");
if (escape)
{
return;
}
switch (result)
{
case "S":
numRisers = 1;
single = true;
break;
case "M":
prompt = "\nUnEven or Even Spacing [U/E]";
escape = UserInput.getUserInputKeyword("U", out result, prompt, "U E");
if (escape)
{
return;
}
switch (result)
{
case "E":
escape = UserInput.getUserInput("Enter # of risers to calculate: ", out result);
if (escape)
{
return;
}
numRisers = int.Parse(result.ToString());
escape = UserInput.getUserInput("Enter Spacing: ", out result);
if (escape)
{
return;
}
distBetween = double.Parse(result.ToString());
Point3d pnt3dEnd = UserInput.getPoint("\nSelect upper RH corner of landing at next riser in direction of target risers:", out ps, osMode: 1);
if (pnt3dEnd == Pub.pnt3dO)
{
return;
}
double distX = pnt3dR0.getDistance(pnt3dEnd);
double diffX = sMath.Round(sMath.Abs(distX - distBetween), 3);
if (diffX > 0)
{
Application.ShowAlertDialog("Distance between picked points and Spacing does not agree. Exiting...");
return;
}
dirPick = pnt3dR0.getDirection(pnt3dEnd);
break;
case "U":
numRisers = 1;
distBetween = 0.0;
dirPick = 0.0;
break;
}
break;
}
int k = 0;
do
{
done2 = single;
for (int p = 0; p < numRisers; p++)
{
double dist0X = 0;
if (distBetween != 0)
{ //multiple risers - even spacing
pnt3dR0 = pnt3dRBase + v3d * p * distBetween;
dist0X = dist0 + (p * distBetween);
pnt3dRff = pnts3dSeg[0] + v3d * dist0X;
if (p == numRisers - 1)
{
done2 = true;
}
}
else if (!single)
{ //multiple risers - uneven spacing
if (k == 0)
{ //
pnt3dRff = pnts3dSeg[0].traverse(dirSegFF, dist0, slope);
dist0X = dist0;
k++;
}
else
{
pnt3dR0 = UserInput.getPoint("Select upper RH corner of landing at next riser: ", out ps, osMode: 8);
if (pnt3dR0 == Pub.pnt3dO)
{
done2 = true;
break;
}
dist0X = Geom.getPerpDistToLine(pnts3dSeg[0], pnts3dSeg[1], pnt3dR0);
pnt3dRff = pnts3dSeg[0].traverse(dirSegFF, dist0X, slope);
}
}
else
{
pnt3dRff = pnts3dSeg[0].traverse(dirSegFF, dist0, slope); //single riser
dist0X = dist0;
}
idCgPnt = pnt3dRff.setPoint(out pntNum, "CPNT-ON");
pnt3dLff = pnt3dRff.traverse(dirRiser, wthRiser, slopeRiser);
idCgPnt = pnt3dLff.setPoint(out pntNum, "CPNT-ON");
double elev0 = pnts3dSeg[0].Z + slope * dist0X;
pnt3dR0 = new Point3d(pnt3dR0.X, pnt3dR0.Y, elev0 - 0.04); //point at upper right side of upper landing
idPoly3d = Draw.addPoly3d(pnt3dRff, pnt3dR0, "CPNT-BRKLINE");
pnt3dL0 = pnt3dR0.traverse(dirRiser, wthRiser, slopeRiser); //point at upper left side of upper landing
idPoly3d = Draw.addPoly3d(pnt3dLff, pnt3dL0, "CPNT-BRKLINE");
Point3dCollection pnts3dR = new Point3dCollection();
pnts3dR.Add(pnt3dR0);
idCgPnt = pnt3dR0.setPoint(out pntNum, "CPNT-ON");
addRiserCallout(idCgPnt, angle0 + pi, -1);
Point3dCollection pnts3dL = new Point3dCollection();
pnts3dL.Add(pnt3dL0);
idCgPnt = pnt3dL0.setPoint(out pntNum, "CPNT-ON");
addRiserCallout(idCgPnt, angle0 + pi, 1);
pnt3dR = pnt3dR0.traverse(angle0, lenLand - trianglationFactor, grdLandU); //point at lower right side of upper landing
pnts3dR.Add(pnt3dR);
idCgPnt = pnt3dR.setPoint(out pntNum, "CPNT-ON");
addRiserCallout(idCgPnt, angle0, 1);
Point3d pnt3dBase = pnt3dR.traverse(angle0, trianglationFactor);
pnt3dL = pnt3dR.traverse(dirRiser, wthRiser, slopeRiser); //point at lower left side of upper landing
pnts3dL.Add(pnt3dL);
idCgPnt = pnt3dL.setPoint(out pntNum, "CPNT-ON");
addRiserCallout(idCgPnt, angle0, -1);
idPoly3d = Draw.addPoly3d(pnt3dR, pnt3dL, "CPNT-BRKLINE");
Dictionary <double, double> res = new Dictionary <double, double>();
done = false;
double dZ = 0.0, adj = 0.0, distX = 0.0, steps = 0.0, rem = 0.0, hgtRiser = 0.0;
int stepX = 0;
double elevSurface = 0.0;
double i = 7.0;
do
{
pnt3dR = new Point3d(pnt3dBase.X, pnt3dBase.Y, pnt3dBase.Z - i / 12.0); //bottom of first step for height - Base was adjusted for triangulationFactor
elevSurface = surf.FindElevationAtXY(pnt3dR.X, pnt3dR.Y);
dZ = pnt3dR.Z - elevSurface;
if (dZ < i / 12)
{
break;
}
Vector3d v3dx = new Vector3d(System.Math.Cos(angle0), System.Math.Sin(angle0), -i / lenTread);
Point3d pnt3dX = surf.GetIntersectionPoint(pnt3dR, v3dx);
distX = pnt3dR.getDistance(pnt3dX);
steps = distX / (lenTread / 12);
rem = System.Math.Truncate(steps) + 1 - steps;
res.Add(i, rem);
if (rem < 0.05)
{
stepX = (int)System.Math.Truncate(steps) + 1;
adj = rem * i / 12;
hgtRiser = i;
if (rem * i < stepX * 0.0625)
{
hgtRiser = i - 0.0625;
adj = adj - stepX * 0.0625 / 12;
}
break;
}
if (i == 4)
{
done = true;
}
i = i - 0.0625;
}while (!done);
string dimV = Conv.decimalToFraction(hgtRiser);
string topTxt = string.Format("({0}) {1}", stepX, dimV);
rSum.Add(new riserSum {
idPoly3d = idPoly3d, angle = angle0, lenLanding = lenLand, topText = topTxt
});
pnts3dR.Add(pnt3dR);
pnt3dL = pnt3dR.traverse(dirRiser, wthRiser, slopeRiser);
pnts3dL.Add(pnt3dL);
for (int n = 1; n < steps; n++)
{
pnt3dR = pnt3dR.traverse(angle0, lenTread / 12 - trianglationFactor); //adjusted to avoid vertical faces
pnts3dR.Add(pnt3dR);
pnt3dL = pnt3dR.traverse(dirRiser, wthRiser, slopeRiser);
pnts3dL.Add(pnt3dL);
idPoly3d = Draw.addPoly3d(pnt3dR, pnt3dL, "CPNT-BRKLINE");
pnt3dR = pnt3dR.traverse(angle0, trianglationFactor); //get back to correct location
pnt3dR = new Point3d(pnt3dR.X, pnt3dR.Y, pnt3dR.Z - hgtRiser / 12);
pnts3dR.Add(pnt3dR);
pnt3dL = pnt3dR.traverse(dirRiser, wthRiser, slopeRiser);
pnts3dL.Add(pnt3dL);
idPoly3d = Draw.addPoly3d(pnt3dR, pnt3dL, "CPNT-BRKLINE");
}
pnt3dR = pnt3dR.traverse(angle0, lenTread / 12 - 0.005); //shorten width of last tread to avoid vertical faces
pnts3dR.Add(pnt3dR);
pnt3dL = pnt3dR.traverse(dirRiser, wthRiser, slopeRiser);
pnts3dL.Add(pnt3dL);
idPoly3d = Draw.addPoly3d(pnt3dR, pnt3dL, "CPNT-BRKLINE");
pnt3dR = pnt3dR.traverse(angle0, 0.005); //makeup for reduced width of tread
pnt3dR = new Point3d(pnt3dR.X, pnt3dR.Y, pnt3dR.Z - (hgtRiser / 12 - adj));
pnts3dR.Add(pnt3dR);
idCgPnt = pnt3dR.setPoint(out pntNum, "CPNT-ON");
addRiserCallout(idCgPnt, angle0, 1);
pnt3dL = pnt3dR.traverse(dirRiser, wthRiser, slopeRiser);
pnts3dL.Add(pnt3dL);
idCgPnt = pnt3dL.setPoint(out pntNum, "CPNT-ON");
addRiserCallout(idCgPnt, angle0, -1);
pnt3dR = pnt3dR.traverse(angle0 + pi / 2, 0.5, slope); //point at toe of stairs / outside face of sidewall
idCgPnt = pnt3dR.setPoint(out pntNum, "CPNT-ON");
pnt3dL = pnt3dL.traverse(angle0 - pi / 2, 0.5, slopeRiser); //point at toe of stairs / outside face of sidewall
idCgPnt = pnt3dL.setPoint(out pntNum, "CPNT-ON");
List <Point3d> pnts3dSegDK = new List <Point3d>();
if (pnts3dDK.Count > 2)
{
x = Geom.getVertexNo(pnts3dDK, pnt3dR);
pnts3dSegDK.Add(pnts3dDK[x]);
pnts3dSegDK.Add(pnts3dDK[x + 1]);
}
else
{
pnts3dSegDK = pnts3dDK;
}
double dirSegDK = pnts3dSegDK[0].getDirection(pnts3dSegDK[1]);
double slopeDK = pnts3dSegDK[0].getSlope(pnts3dSegDK[1]);
double lenR = Geom.getPerpDistToLine(pnts3dSegDK[0], pnts3dSegDK[1], pnt3dR);
Point3d pnt3dRint = pnts3dSegDK[0].traverse(dirSegDK, lenR, slopeDK);
idCgPnt = pnt3dRint.setPoint(out pntNum, "CPNT-ON");
addRiserCallout(idCgPnt, angle0, 1);
double lenL = Geom.getPerpDistToLine(pnts3dSegDK[0], pnts3dSegDK[1], pnt3dL);
Point3d pnt3dLint = pnts3dSegDK[0].traverse(dirSegDK, lenL, slopeDK);
idCgPnt = pnt3dLint.setPoint(out pntNum, "CPNT-ON");
addRiserCallout(idCgPnt, angle0, -1);
if (lenL > lenR)
{
pnts3dDK.Insert(x + 1, pnt3dRint);
pnts3dDK.Insert(x + 2, pnt3dR);
pnts3dDK.Insert(x + 3, pnt3dL);
pnts3dDK.Insert(x + 4, pnt3dLint);
}
else
{
pnts3dDK.Insert(x + 1, pnt3dLint);
pnts3dDK.Insert(x + 2, pnt3dL);
pnts3dDK.Insert(x + 3, pnt3dR);
pnts3dDK.Insert(x + 4, pnt3dRint);
}
ObjectId idPoly3dR = Draw.addPoly3d(pnts3dR, "CPNT-BRKLINE");
ObjectId idPoly3dL = Draw.addPoly3d(pnts3dL, "CPNT-BRKLINE");
tvs = new TypedValue[4];
tvs.SetValue(new TypedValue(1001, apps.lnkRiser), 0);
tvs.SetValue(new TypedValue(1000, "cmdRDR"), 1);
tvs.SetValue(new TypedValue(1000, "R"), 2);
tvs.SetValue(new TypedValue(1005, idPoly3dL.getHandle()), 3);
idPoly3dR.setXData(tvs, apps.lnkRiser);
tvs = new TypedValue[4];
tvs.SetValue(new TypedValue(1001, apps.lnkRiser), 0);
tvs.SetValue(new TypedValue(1000, "cmdRDR"), 1);
tvs.SetValue(new TypedValue(1000, "L"), 2);
tvs.SetValue(new TypedValue(1005, idPoly3dR.getHandle()), 3);
idPoly3dL.setXData(tvs, apps.lnkRiser);
}
}while (!done2);
foreach (riserSum r in rSum)
{
Point3d pnt3dMid = r.idPoly3d.getBegPnt().getMidPoint2d(r.idPoly3d.getEndPnt());
addRiserSummaryCallout(pnt3dMid, r.angle, r.lenLanding, r.topText);
}
Point3dCollection pnts3dDKc = new Point3dCollection();
foreach (Point3d pnt3d in pnts3dDK)
{
pnts3dDKc.Add(pnt3d);
}
ObjectId idPoly3dDK = Draw.addPoly3d(pnts3dDKc, "CPNT-BRKLINE");
poly3dDK.ObjectId.delete();
SnapMode.setOSnap((int)osMode);
}
public static bool offsetSegments(string strSurfaceName, string strSurfaceNameX, ObjectId idLWPlineX, string varLayerName = "")
{
double dblZOff = 0;
int intCase1 = 0, intCase2_1 = 0, intCase2_2 = 0, intCase2_3 = 0, intCase2_4 = 0, intCase2_5 = 0, intCase2_6 = 0, intCase2_7 = 0;
int intCase2_8 = 0, intCase5_1 = 0, intCase5_2 = 0, intCase5_3 = 0, intCase5_4 = 0, intCase5_5 = 0, intCase8_5 = 0, intCase11 = 0;
TinSurface objSurfaceSG = null;
if (strSurfaceName == "SG")
{
objSurfaceSG = Surf.getTinSurface("SG", out exists);
if ((objSurfaceSG == null))
{
Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("Surface SG missing - exiting routine");
return(false);
}
}
ObjectId id3dBrkP = ObjectId.Null, idTextB = ObjectId.Null, idTextE = ObjectId.Null;
string strLayerName = varLayerName;
ObjectId id3dBndry = EW_Build3dPoly.buildArea3dLimit(idLWPlineX, strSurfaceName, strSurfaceNameX, strLayerName); //returns 3D poly with surface elevations, endPnt = begPnt
if (id3dBndry == ObjectId.Null)
{
return(false);
}
string strHandle = idLWPlineX.getHandle().ToString();
string strLayer = idLWPlineX.getLayer();
if (varLayerName == "")
{
dblZOff = EW_Utility1.getDepth(strLayer, strSurfaceNameX); //get depth for area
}
else
{
if (!varLayerName.Contains("_OX-AREA-"))
{
dblZOff = EW_Utility1.getDepth(varLayerName, strSurfaceNameX);
}
else
{
dblZOff = double.Parse(varLayerName.Substring(10));
}
}
Point3d pnt3d0 = new Point3d(0, 0, 0);
Point3d pnt3dX = new Point3d(0, 0, -dblZOff);
id3dBndry.moveObj(pnt3d0, pnt3dX);
if (idLWPlineX == ObjectId.Null)
{
MessageBox.Show("idLWPlineX is null");
}
List <Point3d> varPnts3dBndry0z = idLWPlineX.getCoordinates3dList();
idLWPlineX.delete();
List <Point3d> varPnts3dBndry0zForInt = varPnts3dBndry0z;
varPnts3dBndry0zForInt.RemoveAt(varPnts3dBndry0z.Count - 1); //remove endPnt ==>> endPnt <> begPnt
if (strSurfaceName == "CPNT-ON")
{
strLayerName = "CPNT-BRKLINE";
}
else
{
strLayerName = string.Format("{0}-BRKLINE", strSurfaceName);
}
ObjectIdCollection ids = null;
if (pub.boolDebug)
{
escape = Select.getSelSetFromUser(out ids);
}
else
{
ss = EW_Utility1.buildSSetCPNT_ON_SEGMENTS(strLayerName, varPnts3dBndry0z); //select triangle segments (3dPolylines) by polygon crossing
}
if (ss == null)
{
return(false);
}
ObjectId[] idsSegments = ss.GetObjectIds();
TypedValue[] tvs = new TypedValue[3] {
new TypedValue(1001, "makeBOT"),
new TypedValue(1000, varLayerName),
new TypedValue(1000, "BRKLINES")
};
for (int j = 0; j < idsSegments.Length; j++)
{
strLayer = string.Format("{0}-BRKLINE", strSurfaceNameX);
ObjectId id = idsSegments[j];
ObjectId idBrk = ObjectId.Null;
Entity ent = id.getEnt();
if (ent.GetType() == typeof(PolylineVertex3d))
{
idBrk = id.getOwnerOfVertex2d3d();
}
else if (ent.GetType() == typeof(Polyline3d))
{
idBrk = id;
}
//ent = idBrk.getEnt();
//MessageBox.Show(ent.GetType().ToString());
ObjectId id3dBrkX = idBrk.copy(strLayer);
//ent = id3dBrkX.getEnt();
//MessageBox.Show(ent.GetType().ToString());
id3dBrkX.moveObj(pnt3d0, pnt3dX); //move copy of triangle edge based on vertical offset
id3dBrkX.changeProp(clr.byl, strLayer);
//ent = id3dBrkX.getEnt();
//MessageBox.Show(ent.GetType().ToString());
List <Point3d> varPnts3d = id3dBrkX.getCoordinates3dList();
Point3d dblPntBeg = varPnts3d[0];
Point3d dblPntEnd = varPnts3d[1]; //end point of triangle edge (3dPoly segment)
if (pub.boolDebug)
{
idTextB = Txt.addText("B", dblPntBeg, 0, AttachmentPoint.BottomLeft);
idTextB.changeProp(color, "DEBUG-0", LineWeight.LineWeight020);
}
if (pub.boolDebug)
{
idTextE = Txt.addText("E", dblPntBeg, 0, AttachmentPoint.BottomLeft);
idTextE.changeProp(color, "DEBUG-0", LineWeight.LineWeight020);
}
//------------------------------------------------------------------test for intersection
List <Point3d> dblPntInts = Geom.getPntInts(dblPntBeg, dblPntEnd, varPnts3dBndry0zForInt, false, extend.none);
//------------------------------------------------------------------test for intersection
bool boolAddEnt = false;
bool boolBegOnSeg = false;
bool boolEndOnSeg = false;
bool boolBegIn = false;
bool boolEndIn = false;
int intUBnd = 0;
switch ((int)(dblPntInts[0].X))
{
case -1:
intUBnd = -1;
boolBegOnSeg = (dblPntBeg.isOn2dSegment(varPnts3dBndry0zForInt) == -1) ? false : true;
boolEndOnSeg = (dblPntEnd.isOn2dSegment(varPnts3dBndry0zForInt) == -1) ? false : true;
break;
case -9:
intUBnd = -9;
boolBegOnSeg = true;
boolEndOnSeg = true;
break;
default:
intUBnd = dblPntInts.Count;
boolBegOnSeg = (dblPntBeg.isOn2dSegment(varPnts3dBndry0zForInt) == -1) ? false : true;
boolEndOnSeg = (dblPntEnd.isOn2dSegment(varPnts3dBndry0zForInt) == -1) ? false : true;
break;
}
if (boolBegOnSeg == false)
{
boolBegIn = dblPntBeg.isInside(varPnts3dBndry0zForInt);
}
else
{
boolBegIn = true;
}
if (boolEndOnSeg == false)
{
boolEndIn = dblPntEnd.isInside(varPnts3dBndry0zForInt);
}
else
{
boolEndIn = true;
}
switch (intUBnd)
{
case -1:
//Case -1
if (boolBegOnSeg & !boolEndIn)
{
boolAddEnt = false;
}
else if (boolEndOnSeg & !boolBegIn)
{
boolAddEnt = false;
}
else
{
boolAddEnt = true;
intCase1 = intCase1 + 1;
}
break;
case 1: //one intersection - one point inside and one outside
//Case 2-1
if (boolBegOnSeg == true & boolEndOnSeg == true)
{
//both ends on the line
//test midPoint to see if segment is inside or outside
Point3d pnt3dMid = dblPntBeg.getMidPoint3d(dblPntEnd);
//boolAddEnt = (pnt3dMid.isOn2dSegment(varPnts3dBndry0zForInt) == -1) ? true : false;
boolAddEnt = pnt3dMid.isInside(varPnts3dBndry0zForInt);
if (boolAddEnt)
{
intCase5_1 = intCase2_1 + 1;
}
//Case 2-2
}
else if (boolBegOnSeg == true & boolEndIn == true)
{
boolAddEnt = true;
intCase2_2 = intCase2_2 + 1;
//Case 2-3 ???????????????????????????????????
}
else if (boolBegOnSeg == true & boolEndIn == false)
{
if (dblPntInts[0].isOn2dSegment(varPnts3dBndry0zForInt) != -1)
{
dblPntEnd = dblPntInts[0];
double elev = EW_Utility2.getElev(dblPntEnd, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntEnd.X, dblPntEnd.Y);
}
dblPntEnd = dblPntEnd.addElevation(elev);
boolAddEnt = true;
}
else
{
boolAddEnt = false;
intCase2_3 = intCase2_3 + 1;
}
//Case 2-4
}
else if (boolEndOnSeg == true & boolBegIn == true)
{
boolAddEnt = true;
intCase2_4 = intCase2_4 + 1;
//Case 2-5
}
else if (boolEndOnSeg == true & boolBegIn == false)
{
if (dblPntInts[0].isOn2dSegment(varPnts3dBndry0zForInt) != -1)
{
dblPntBeg = dblPntInts[0];
double elev = EW_Utility2.getElev(dblPntBeg, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntBeg.X, dblPntBeg.Y);
}
dblPntBeg = dblPntBeg.addElevation(elev);
boolAddEnt = true;
}
else
{
boolAddEnt = false;
intCase2_5 = intCase2_5 + 1;
}
//Case 2-6
}
else if (boolBegIn == true & boolEndIn == false)
{
dblPntEnd = dblPntInts[0];
double elev = EW_Utility2.getElev(dblPntEnd, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntEnd.X, dblPntEnd.Y);
}
dblPntEnd = dblPntEnd.addElevation(elev);
boolAddEnt = true;
intCase2_6 = intCase2_6 + 1;
//Case 2-7
}
else if (boolBegIn == false & boolEndIn == true)
{
dblPntBeg = dblPntInts[0];
double elev = EW_Utility2.getElev(dblPntBeg, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntBeg.X, dblPntBeg.Y);
}
dblPntBeg = dblPntBeg.addElevation(elev);
boolAddEnt = true;
intCase2_7 = intCase2_7 + 1;
//Case2-8
}
else if (boolBegIn == true & boolEndIn == true)
{
boolAddEnt = true;
intCase2_8 = intCase2_8 + 1;
}
break;
case 2:
//Case 5-1
if (boolBegOnSeg == true & boolEndOnSeg == true)
{
//both ends on the line
//test miPoint3d to see if segment is inside or outside
Point3d pnt3dMid = dblPntBeg.getMidPoint3d(dblPntEnd);
boolAddEnt = pnt3dMid.isInside(varPnts3dBndry0zForInt);
if (boolAddEnt)
{
intCase5_1 = intCase5_1 + 1;
}
//Case 5-2
}
else if (boolBegIn == false & boolEndIn == false)
{
dblPntBeg = dblPntInts[0];
double elev = EW_Utility2.getElev(dblPntBeg, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntBeg.X, dblPntBeg.Y);
}
dblPntBeg = dblPntBeg.addElevation(elev);
dblPntEnd = dblPntInts[1];
elev = EW_Utility2.getElev(dblPntEnd, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntEnd.X, dblPntEnd.Y);
}
dblPntEnd = dblPntEnd.addElevation(elev);
boolAddEnt = true;
intCase5_2 = intCase5_2 + 1;
//Case 5-3
}
else if (boolBegOnSeg == true & boolEndIn == false)
{
dblPntBeg = dblPntInts[0];
double elev = EW_Utility2.getElev(dblPntBeg, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntBeg.X, dblPntBeg.Y);
}
dblPntBeg = dblPntBeg.addElevation(elev);
dblPntEnd = dblPntInts[1];
elev = EW_Utility2.getElev(dblPntEnd, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntEnd.X, dblPntEnd.Y);
}
dblPntEnd = dblPntEnd.addElevation(elev);
boolAddEnt = true;
intCase5_3 = intCase5_3 + 1;
//Case 5-4
}
else if (boolEndOnSeg == true & boolBegIn == false)
{
dblPntBeg = dblPntInts[0];
double elev = EW_Utility2.getElev(dblPntBeg, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntBeg.X, dblPntBeg.Y);
}
dblPntBeg = dblPntBeg.addElevation(elev);
dblPntEnd = dblPntInts[1];
elev = EW_Utility2.getElev(dblPntEnd, id3dBndry);
if (elev == 0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntEnd.X, dblPntEnd.Y);
}
dblPntEnd = dblPntEnd.addElevation(elev);
boolAddEnt = true;
intCase5_4 = intCase5_4 + 1;
//Case 5-5
}
else if (boolBegIn == true & boolEndIn == true)
{
boolAddEnt = true;
intCase5_5 = intCase5_5 + 1;
}
break;
case 3:
//Case 8
List <Point3d> dblPntInts_New = new List <Point3d>();
for (int s = dblPntInts.Count; s > 0; s--)
{
if (System.Math.Round(dblPntBeg.X, 3) == System.Math.Round(dblPntInts[s - 1].X, 3) &&
System.Math.Round(dblPntBeg.Y, 3) == System.Math.Round(dblPntInts[s - 1].Y, 3))
{
dblPntInts.RemoveAt(s - 1);
}
}
for (int s = dblPntInts.Count; s > 0; s--)
{
if (System.Math.Round(dblPntEnd.X, 3) == System.Math.Round(dblPntInts[s - 1].X, 3) &&
System.Math.Round(dblPntEnd.Y, 3) == System.Math.Round(dblPntInts[s - 1].Y, 3))
{
dblPntInts.RemoveAt(s - 1);
}
}
switch (dblPntInts.Count)
{
case 2:
double dblDist1 = dblPntBeg.getDistance(dblPntInts[0]);
double dblDist2 = dblPntBeg.getDistance(dblPntInts[1]);
if (dblDist1 > dblDist2)
{
Point3d pnt3dTmp = dblPntInts[0];
dblPntInts[0] = dblPntInts[1];
dblPntInts[1] = pnt3dTmp;
}
Point3d dblPntMid = dblPntBeg + (dblPntInts[0] - dblPntBeg) / 2;
if (dblPntMid.isInside(varPnts3dBndry0zForInt))
{
Point3d dblPntInt = dblPntInts[0];
List <Point3d> dblPnts3dBrk = new List <Point3d>();
dblPnts3dBrk.Add(dblPntBeg);
double elev = EW_Utility2.getElev(dblPntInt, id3dBndry);
if (elev == 0.0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntInt.X, dblPntInt.Y);
}
dblPntInt.addElevation(elev);
dblPnts3dBrk.Add(dblPntInt);
ObjectId id3dBrkXNew = Draw.addPoly3d(dblPnts3dBrk, strSurfaceNameX + "-BRKLINE");
id3dBrkXNew.changeProp(LineWeight.ByLayer, Color.FromColorIndex(ColorMethod.ByAci, 0));
id3dBrkXNew.setXData(tvs, "makeBOT");
intCase5_1 = intCase5_1 + 1;
id3dBrkX.delete();
}
dblPntMid = dblPntInts[1] + (dblPntEnd - dblPntInts[1]) / 2;
if (dblPntMid.isInside(varPnts3dBndry0zForInt))
{
Point3d dblPntInt = dblPntInts[1];
List <Point3d> dblPnts3dBrk = new List <Point3d>();
double elev = EW_Utility2.getElev(dblPntInt, id3dBndry);
if (elev == 0.0 && strSurfaceName == "SG")
{
elev = objSurfaceSG.FindElevationAtXY(dblPntInt.X, dblPntInt.Y);
}
dblPntInt.addElevation(elev);
dblPnts3dBrk.Add(dblPntInt);
dblPnts3dBrk.Add(dblPntEnd);
ObjectId id3dBrkXNew = Draw.addPoly3d(dblPnts3dBrk, strSurfaceNameX + "-BRKLINE");
id3dBrkXNew.changeProp(LineWeight.ByLayer, Color.FromColorIndex(ColorMethod.ByAci, 0));
id3dBrkXNew.setXData(tvs, "makeBOT");
intCase8_5 = intCase8_5 + 1;
id3dBrkX.delete();
}
break;
case 3:
break;
}
break;
case 4:
//Case 11
intCase11 = intCase11 + 1;
break;
case -9:
boolAddEnt = false;
break;
}
if (boolAddEnt == true)
{
id3dBrkX.delete();
id3dBrkP = Draw.addPoly3d(dblPntBeg, dblPntEnd, strLayer);
id3dBrkP.setXData(tvs, "makeBOT");
if (pub.boolDebug)
{
id3dBrkX.changeProp(LineWeight.LineWeight200, clr.byl);
id3dBrkP = id3dBrkX;
}
}
else
{
// obj3dBrkX.Delete
}
if (pub.boolDebug)
{
idTextB.delete();
idTextE.delete();
ss = EW_Utility1.buildSSet7();
ss.eraseSelectedItems();
}
}
//Debug.Print "Case -1 " & intCase1
//Debug.Print "Case 2-1 " & intCase2_1
//Debug.Print "Case 2-2 " & intCase2_2
//Debug.Print "Case 2-3 " & intCase2_3
//Debug.Print "Case 2-4 " & intCase2_4
//Debug.Print "Case 2-5 " & intCase2_5
//Debug.Print "Case 2-6 " & intCase2_6
//Debug.Print "Case 2-7 " & intCase2_7
//Debug.Print "Case 2-8 " & intCase2_8
//Debug.Print "Case 5-1 " & intCase5_1
//Debug.Print "Case 5-2 " & intCase5_2
//Debug.Print "Case 5-3 " & intCase5_3
//Debug.Print "Case 5-4 " & intCase5_4
//Debug.Print "Case 5-5 " & intCase5_5
//Debug.Print "Case 8-5 " & intCase8_5
//Debug.Print "Case 8-8 " & intCase8_8
//Debug.Print "Case 11 " & intCase11
//Debug.Print "Total=" & intCase1 + intCase2_1 + intCase2_2 + intCase2_3 + intCase2_4 + intCase2_5 + intCase2_6 + _
//' intCase2_7 + intCase2_8 + intCase5_1 + intCase5_2 + intCase5_3 + intCase5_4 + intCase5_5 + _
//' intCase8_5 + intCase8_8 + intCase11
return(true);
}
CreateProfileByDesign2b(Alignment objAlignPL, Alignment objAlignRF)
{
Profile objProfileDES = null;
Profile objprofilePL = Prof.getProfile(objAlignPL.Name, "EXIST");
Profile objProfileRF = Prof.getProfile(objAlignRF.Name, "CPNT");
double XT = 0;
double X1 = 0;
double X2 = 0;
double X0 = Convert.ToDouble(fWall1.tbx_X0.Text);
double S0 = Convert.ToDouble(fWall1.tbx_S0.Text);
double CF = Convert.ToDouble(fWall1.tbx_CF.Text);
double B1 = Convert.ToDouble(fWall1.tbx_B1.Text);
double S1 = Convert.ToDouble(fWall1.tbx_S1.Text);
double SG = Convert.ToDouble(fWall1.tbx_SG.Text);
double B2 = Convert.ToDouble(fWall1.tbx_B2.Text);
double S2 = Convert.ToDouble(fWall1.tbx_S2.Text);
double dblOffsetPL = 0;
double dblEasting = 0;
double dblNorthing = 0;
List <Point3d> pnts3dX0 = new List <Point3d>();
List <Point3d> pnts3dFL = new List <Point3d>();
List <Point3d> pnts3dTC = new List <Point3d>();
List <Point3d> pnts3dTOE = new List <Point3d>();
List <Point3d> pnts3dTS = new List <Point3d>();
List <Point3d> pnts3dTOP = new List <Point3d>();
List <Point3d> pnts3dWT0 = new List <Point3d>();
List <Point3d> pnts3dWB0 = new List <Point3d>();
List <Point3d> pnts3dWTB = new List <Point3d>();
List <Point3d> pnts3dWBB = new List <Point3d>();
short intSign = 0;
double dblElevRF = 0;
double dblElevFL = 0;
double dblElevTC = 0;
double dblElevTOE = 0;
double dblElevTS = 0;
double dblElevTOP = 0;
double dblElevWT0 = 0;
double dblElevWB0 = 0;
double dblElevWTB = 0;
double dblElevWBB = 0;
double dblElevPL = 0;
double dblWallWidth = 10 / 12;
double dblStationRF = 0;
double dblStationPL = 0;
ObjectId idPoly3d = ObjectId.Null;
Point3d pnt3d = default(Point3d);
string strLayerName = null;
bool boolDesLow = false;
bool boolDesHigh = false;
strLayerName = "PROFILE-CPNT";
ObjectId idLayer = Layer.manageLayers(strLayerName);
objAlignRF.PointLocation(objAlignRF.StartingStation, 0, ref dblEasting, ref dblNorthing);
try
{
objAlignPL.StationOffset(dblEasting, dblNorthing, ref dblStationPL, ref dblOffsetPL);
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
dblStationPL = 0.0;
}
if (dblOffsetPL < 0)
{
intSign = -1;
dblOffsetPL = dblOffsetPL * -1;
}
else
{
intSign = 1;
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Dim varPNT_DATA_FINAL() As PNT_DATA = getPNT_DATA_FINAL(objAlignPL, objAlignRF)
List <double> dblStationsFinal = wd.getPNT_DATA_FINAL(objAlignPL, objAlignRF);
fWall1.Stations = dblStationsFinal;
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
if ((fWall1.Stations == null))
{
return;
}
else
{
objProfileRF = Prof.getProfile(objAlignRF.Name, "CPNT");
objprofilePL = Prof.getProfile(objAlignPL.Name, "EXIST");
}
//-------CREATE PROFILE FOR DESIGN SURFACE AT WALL/PL ALIGNMENT
try
{
Prof.removeProfile(objAlignPL.ObjectId, "CPNT");
//Dim idProfileStyle As ObjectId = Prof_Style.getProfileStyle("WALL")
//Dim idStyleLabelSet As ObjectId = Prof_Style.getProfileLabelSetStyle("WALL")
ObjectId idProfileStyle = Prof_Style.getProfileStyle("Standard");
ObjectId idStyleLabelSet = Prof_Style.getProfileLabelSetStyle("Standard");
using (BaseObjs._acadDoc.LockDocument())
{
using (Transaction TR = BaseObjs.startTransactionDb())
{
objProfileDES = Prof.addProfileByLayout("CPNT", objAlignPL.ObjectId, idLayer, idProfileStyle, idStyleLabelSet);
TR.Commit();
}
}
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
double dblAngOFF = 0;
double dblAngWALL = 0;
double dblSkew = 0;
Point3d pnt3dBeg = default(Point3d);
Point3d pnt3dEnd = default(Point3d);
pnt3dBeg = objAlignRF.StartPoint;
pnt3dEnd = objAlignRF.EndPoint;
dblAngOFF = Measure.getAzRadians(pnt3dBeg, pnt3dEnd);
pnt3dBeg = objAlignPL.StartPoint;
pnt3dEnd = objAlignPL.EndPoint;
dblAngWALL = Measure.getAzRadians(pnt3dBeg, pnt3dEnd);
dblSkew = dblAngWALL - dblAngOFF;
bool boolStart = false;
bool boolDone = false;
for (int i = 0; i < dblStationsFinal.Count; i++)
{
dblStationRF = Math.roundDown1(dblStationsFinal[i]);
//CURRENT STATION ON RF
objAlignRF.PointLocation(dblStationRF, 0.0, ref dblEasting, ref dblNorthing);
try
{
objAlignPL.StationOffset(dblEasting, dblNorthing, ref dblStationPL, ref dblOffsetPL);
// CORRESPONDING STATION ON PL
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
dblStationPL = 0.0;
}
if (System.Math.Round(dblStationPL, 1) >= System.Math.Round(objAlignPL.StartingStation, 1))
{
boolStart = true;
}
if (System.Math.Round(dblStationPL, 1) <= System.Math.Round(objAlignPL.EndingStation, 1))
{
boolDone = false;
}
if (boolStart == true & boolDone == false)
{
dblElevRF = objProfileRF.ElevationAt(dblStationRF);
//elevation on RF at current RF station
dblElevFL = dblElevRF + (X0 - 0.15) * S0;
dblElevTC = dblElevFL + CF / 12;
dblElevPL = objprofilePL.ElevationAt(dblStationPL);
if (dblElevRF > 0 & dblElevPL > 0)
{
dblElevTS = dblElevPL - (B2 * S2);
objAlignRF.PointLocation(dblStationRF, X0 - 0.15, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevFL);
pnts3dFL.Add(pnt3d);
objAlignRF.PointLocation(dblStationRF, X0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTC);
pnts3dTC.Add(pnt3d);
if (dblElevTS - dblElevTC > 0)
{
boolDesLow = true;
boolDesHigh = false;
}
else if (dblElevTC - dblElevTS > 0)
{
boolDesHigh = true;
boolDesLow = false;
}
if (boolDesLow)
{
objAlignRF.PointLocation(dblStationRF, B1, ref dblEasting, ref dblNorthing);
//point location at back of B1
try
{
objAlignPL.StationOffset(dblEasting, dblNorthing, ref dblStationPL, ref dblOffsetPL);
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
dblStationPL = 0.0;
}
if (dblStationPL == 0)
{
pnt3dBeg = new Point3d(dblEasting, dblNorthing, 0.0);
pnt3dEnd = objAlignPL.EndPoint;
dblOffsetPL = pnt3dBeg.getDistance(pnt3dEnd);
}
XT = System.Math.Abs(dblOffsetPL) - X0;
X2 = ((dblElevTC - dblElevPL) + (XT - B2) * S1 + (B2 * S2)) / (S1 - SG);
//slope width
if (X2 >= 0)
{
X1 = XT - X2;
if (X1 >= 0)
{
dblElevTOE = dblElevTC + (S1 * B1) + (X1 * S1);
objAlignPL.PointLocation(dblStationPL, (X2 + B2) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnts3dTOE.Add(pnt3d);
dblElevTS = dblElevTOE + X2 * SG;
objAlignPL.PointLocation(dblStationPL, (B2)*intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTS);
pnts3dTS.Add(pnt3d);
dblElevTOP = dblElevTS + B2 * S2;
objAlignPL.PointLocation(dblStationPL, 0.0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnts3dTOP.Add(pnt3d);
try
{
objProfileDES.PVIs.AddPVI(dblStationPL, dblElevTOP);
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
}
else
{
//here is where we put the wall at the limit of pavement or at back of B1
X1 = B1;
X2 = XT - X1;
dblElevTOE = dblElevTC + X1 * S1;
objAlignRF.PointLocation(dblStationRF, X1 + 0.1, ref dblEasting, ref dblNorthing);
//point perp to RF
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnts3dTOE.Add(pnt3d);
dblElevTS = dblElevTOE + X2 * SG;
objAlignPL.PointLocation(dblStationPL, B2 * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTS);
pnts3dTS.Add(pnt3d);
dblElevTOP = dblElevTS + B2 * S2;
objAlignPL.PointLocation(dblStationPL, 0.0, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnts3dTOP.Add(pnt3d);
//wall location
dblElevWT0 = dblElevPL + 1.0;
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevWT0);
pnts3dWT0.Add(pnt3d);
dblElevWB0 = dblElevTOP - 1.0;
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevWB0);
pnts3dWB0.Add(pnt3d);
dblElevWTB = dblElevWT0;
objAlignPL.PointLocation(dblStationRF, dblWallWidth * intSign * -1, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevWT0);
pnts3dWTB.Add(pnt3d);
dblElevWBB = dblElevWB0;
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevWBB);
pnts3dWBB.Add(pnt3d);
try
{
objProfileDES.PVIs.AddPVI(dblStationRF, dblElevTOP);
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
}
}
//wall at pl
}
else if (boolDesHigh)
{
X1 = B1;
X2 = XT - X1;
dblElevTOE = dblElevTC + X1 * S1;
objAlignRF.PointLocation(dblStationRF, X1 + 0.1, ref dblEasting, ref dblNorthing);
//point perp to OFF at back of bench
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnts3dTOE.Add(pnt3d);
dblElevTS = dblElevTOE + X2 * S1;
objAlignPL.PointLocation(dblStationPL, B2 * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTS);
pnts3dTS.Add(pnt3d);
dblElevTOP = dblElevTS + B2 * S2;
objAlignPL.PointLocation(dblStationRF, 0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnts3dTOP.Add(pnt3d);
//WALL Limits
dblElevWT0 = dblElevTOP + 1.0;
//wall top 0 offset
objAlignPL.PointLocation(dblStationRF, 0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevWT0);
pnts3dWT0.Add(pnt3d);
dblElevWB0 = dblElevPL - 1.0;
//wall bottom 0.1 offset
objAlignPL.PointLocation(dblStationRF, 0.1 * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevWB0);
pnts3dWB0.Add(pnt3d);
dblElevWTB = dblElevWT0;
//wall top WallWidth offset
objAlignPL.PointLocation(dblStationRF, dblWallWidth * intSign * -1, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevWT0);
pnts3dWTB.Add(pnt3d);
dblElevWBB = dblElevWB0;
//Wall bottom WallWidth + 0.1 offset
objAlignPL.PointLocation(dblStationRF, (dblWallWidth + 0.1) * intSign * -1, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevWBB);
pnts3dWBB.Add(pnt3d);
try
{
objProfileDES.PVIs.AddPVI(dblStationRF, dblElevTOP);
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
}
}
}
}
try
{
ObjectIdCollection objEntIDs = new ObjectIdCollection();
ObjectIdCollection objEntWallIDs = new ObjectIdCollection();
TypedValue[] tvs = new TypedValue[2];
tvs[0] = new TypedValue(1001, "WALL");
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dFL, "CPNT-BRKLINE", 1);
tvs[1] = new TypedValue(1000, "FL");
idPoly3d.setXData(tvs, "WALL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTC, "CPNT-BRKLINE", 2);
tvs[1] = new TypedValue(1000, "TC");
idPoly3d.setXData(tvs, "WALL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTOE, "CPNT-BRKLINE", 3);
tvs[1] = new TypedValue(1000, "TOE");
idPoly3d.setXData(tvs, "WALL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTS, "CPNT-BRKLINE", 4);
tvs[1] = new TypedValue(1000, "TS");
idPoly3d.setXData(tvs, "WALL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTOP, "CPNT-BRKLINE", 5);
tvs[1] = new TypedValue(1000, "TOP");
idPoly3d.setXData(tvs, "WALL");
objEntIDs.Add(idPoly3d);
string strLayer = string.Format("{0}-BRKLINE", objAlignPL.Name);
Layer.manageLayers(strLayer);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dWB0, strLayer, 11);
tvs[1] = new TypedValue(1000, "WB0");
idPoly3d.setXData(tvs, "WALL");
objEntWallIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dWT0, strLayer, 170);
tvs[1] = new TypedValue(1000, "WT0");
idPoly3d.setXData(tvs, "WALL");
objEntWallIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dWTB, strLayer, 170);
tvs[1] = new TypedValue(1000, "WTB");
idPoly3d.setXData(tvs, "WALL");
objEntWallIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dWBB, strLayer, 11);
tvs[1] = new TypedValue(1000, "WBB");
idPoly3d.setXData(tvs, "WALL");
objEntWallIDs.Add(idPoly3d);
ObjectIdCollection objEntEndIDs = default(ObjectIdCollection);
objEntEndIDs = wdp.makeEndBrklinesWALL(strLayer, objEntIDs, false);
bool exists = false;
TinSurface objSurfaceCPNT = Surf.getTinSurface("CPNT-ON", out exists);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntIDs, 0, 0, 0, 0);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntEndIDs, 0, 0, 0, 0);
TinSurface objSurfaceWall = Surf.getTinSurface(objAlignPL.Name, out exists);
objSurfaceWall.BreaklinesDefinition.AddStandardBreaklines(objEntWallIDs, 0, 0, 0, 0);
objEntEndIDs = wdp.makeEndBrklinesWALL(strLayer, objEntWallIDs, true);
objSurfaceWall.BreaklinesDefinition.AddStandardBreaklines(objEntEndIDs, 0, 0, 0, 0);
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
objProfileDES.Layer = strLayerName;
}
CreateProfileByDesign2c(Alignment objAlignPL, Alignment objAlignRF, List <PNT_DATA> varPNT_DATA)
{
short i = 0;
Profile objProfilePL = default(Profile);
Profile objProfileRF = default(Profile);
double XT = 0;
double X1 = 0;
double Xo = 0;
double X0 = Convert.ToDouble(fWall1.tbx2c_X0.Text);
double B1 = Convert.ToDouble(fWall1.tbx2c_B1.Text);
double B2 = Convert.ToDouble(fWall1.tbx2c_B2.Text);
double S0 = Convert.ToDouble(fWall1.tbx2c_S0.Text);
double S1 = Convert.ToDouble(fWall1.tbx2c_S1.Text);
double S2 = Convert.ToDouble(fWall1.tbx2c_S2.Text);
double SG = Convert.ToDouble(fWall1.tbx2c_SG.Text);
double CF = Convert.ToDouble(fWall1.tbx2c_CF.Text);
double dblOffsetPL = 0.0;
double dblEasting = 0.0;
double dblNorthing = 0.0;
List <Point3d> pnts3dRF = new List <Point3d>();
List <Point3d> pnts3dFL = new List <Point3d>();
List <Point3d> pnts3dTC = new List <Point3d>();
List <Point3d> pnts3dTOE = new List <Point3d>();
List <Point3d> pnts3dTOP = new List <Point3d>();
List <Point3d> pnts3dPL = new List <Point3d>();
short intSign = 0;
double dblElevRF = 0;
double dblElevFL = 0;
double dblElevTC = 0;
double dblElevTOE = 0;
double dblElevTOP = 0;
double dblElevPL = 0;
double dblElevDiff = 0;
double dblStationRF = 0;
double dblStationPL = 0;
Point3d pnt3d = default(Point3d);
ObjectId idPoly3d = ObjectId.Null;
string strLayerName = null;
strLayerName = "PROFILE-CPNT";
Layer.manageLayers(strLayerName);
objAlignRF.PointLocation(objAlignRF.StartingStation, 0, ref dblEasting, ref dblNorthing);
try
{
objAlignPL.StationOffset(dblEasting, dblNorthing, ref dblStationPL, ref dblOffsetPL);
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
dblStationPL = 0.0;
}
if (dblOffsetPL < 0)
{
intSign = -1;
}
else
{
intSign = 1;
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Dim varPNT_DATA_FINAL() As PNT_DATA = getPNT_DATA_FINAL(objAlignPL, objAlignRF)
List <double> dblStationsFinal = new List <double>();
dblStationsFinal = wd.getPNT_DATA_FINAL(objAlignPL, objAlignRF);
fWall1.Stations = dblStationsFinal;
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
if ((fWall1.Stations == null))
{
return;
}
else
{
objProfileRF = Prof.getProfile(objAlignRF.ObjectId, "CPNT");
objProfilePL = Prof.getProfile(objAlignPL.ObjectId, "EXIST");
}
//-------CREATE PROFILE FOR DESIGN SURFACE AT WALL/PL ALIGNMENT
bool boolStart = false;
bool boolDone = false;
for (i = 0; i <= dblStationsFinal.Count - 1; i++)
{
dblStationRF = dblStationsFinal[i];
//CURRENT STATION ON REF
Debug.Print(dblStationRF.ToString());
objAlignRF.PointLocation(dblStationRF, 0.0, ref dblEasting, ref dblNorthing);
try
{
objAlignPL.StationOffset(dblEasting, dblNorthing, ref dblStationPL, ref dblOffsetPL);
// CORRESPONDING STATION ON PL
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
dblStationPL = 0.0;
}
//CHECK IF
if (System.Math.Round(dblStationRF, 1) >= System.Math.Round(objAlignRF.StartingStation, 1))
{
boolStart = true;
}
if (System.Math.Round(dblStationRF, 1) <= System.Math.Round(objAlignRF.EndingStation, 1))
{
boolDone = false;
}
if (boolStart == true & boolDone == false)
{
dblElevRF = objProfileRF.ElevationAt(dblStationRF);
//elevation on REF at current REF station
dblElevPL = objProfilePL.ElevationAt(dblStationPL);
//elevation on PL at PL station corresponding to REF station
//valid surface elevations for both REF and PL
if (dblElevRF > 0 & dblElevPL > 0)
{
dblElevTOP = dblElevPL - (B2 * S2);
//top of slope - always sloping away from PL
objAlignRF.PointLocation(dblStationRF, 0.0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevRF);
pnts3dRF.Add(pnt3d);
dblElevDiff = dblElevRF - dblElevPL;
objAlignRF.PointLocation(dblStationRF, 0.0, ref dblEasting, ref dblNorthing);
//point location at REF align
try
{
objAlignPL.StationOffset(dblEasting, dblNorthing, ref dblStationPL, ref dblOffsetPL);
//station and offset from PL to REF
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
dblStationPL = 0.0;
}
//0 station means that the return station was outside limits
if (dblStationPL == 0)
{
Point3d pnt3dBeg = new Point3d(dblEasting, dblNorthing, 0.0);
//point location at REF align
dblStationPL = objAlignPL.EndingStation;
objAlignPL.PointLocation(objAlignPL.EndingStation, 0, ref dblEasting, ref dblNorthing);
Point3d pnt3dEnd = new Point3d(dblEasting, dblNorthing, 0.0);
//point location at end PL align
dblOffsetPL = pnt3dBeg.getDistance(pnt3dEnd);
//distance from REF to PL
}
XT = System.Math.Abs(dblOffsetPL);
double SLOPE = 0.0;
//PL lower than REF - slope down
if (dblElevDiff >= 0)
{
SLOPE = SG * -1;
}
else
{
SLOPE = SG;
}
X1 = ((dblElevPL - dblElevRF) - (XT * S0) - B1 * (S1 - S0) - B2 * (S2 - S0) - CF / 12) / (SLOPE - S0);
if (X1 < 0)
{
SLOPE = SLOPE * -1;
X1 = ((dblElevPL - dblElevRF) - (XT * S0) - B1 * (S1 - S0) - B2 * (S2 - S0) - CF / 12) / (SLOPE - S0);
}
Xo = XT - X1 - B1 - B2;
if (X0 > Xo)
{
}
dblElevFL = dblElevRF + X0 * S0;
objAlignPL.PointLocation(dblStationPL, (XT - X0 + 0.15) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevFL);
pnts3dFL.Add(pnt3d);
dblElevTC = dblElevFL + CF / 12;
objAlignPL.PointLocation(dblStationPL, (XT - X0) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTC);
pnts3dTC.Add(pnt3d);
dblElevTOE = (dblElevTC + B1 * S1);
objAlignPL.PointLocation(dblStationPL, (XT - X0 - B1) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnts3dTOE.Add(pnt3d);
dblElevTOP = dblElevTOE + X1 * SLOPE;
objAlignPL.PointLocation(dblStationPL, (B2)*intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnts3dTOP.Add(pnt3d);
dblElevPL = dblElevTOP + B2 * S2;
objAlignPL.PointLocation(dblStationPL, 0.0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevPL);
pnts3dPL.Add(pnt3d);
}
}
}
try
{
ObjectIdCollection objEntIDs = new ObjectIdCollection();
TypedValue[] tvs = new TypedValue[2];
tvs[0] = new TypedValue(1001, "PL");
idPoly3d = Draw.addPoly3d(pnts3dRF, color: 6);
tvs[1] = new TypedValue(1000, "REF");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dFL, "CPNT-BRKLINE", 1);
tvs[1] = new TypedValue(1000, "FL");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTC, "CPNT-BRKLINE", 2);
tvs[1] = new TypedValue(1000, "TC");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTOE, "CPNT-BRKLINE", 3);
tvs[1] = new TypedValue(1000, "TOE");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTOP, "CPNT-BRKLINE", 4);
tvs[1] = new TypedValue(1000, "TOP");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dPL, "CPNT-BRKLINE", 5);
tvs[1] = new TypedValue(1000, "PL");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
string strLayer = string.Format("{0}-BRKLINE", objAlignPL.Name);
Layer.manageLayers(strLayer);
ObjectIdCollection objEntEndIDs = new ObjectIdCollection();
objEntEndIDs = makeEndBrklinesORG(strLayer, objEntIDs, false);
bool exists = false;
TinSurface objSurfaceCPNT = Surf.getTinSurface("CPNT-ON", out exists);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntIDs, 0, 0, 0, 0);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntEndIDs, 0, 0, 0, 0);
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
}
drawSections()
{
Alignment objAlign = default(Alignment);
try {
objAlign = fWall1.ACTIVEALIGN;
if ((objAlign == null))
{
MessageBox.Show("Select Alignment");
return;
}
}
catch (System.Exception) {
MessageBox.Show("Select Alignment");
return;
}
bool exists = false;
TinSurface objSurfaceEXIST = Surf.getTinSurface("EXIST", out exists);
TinSurface objSurfaceCPNT = Surf.getTinSurface("CPNT-ON", out exists);
//ObjectId objSectionStyleEXISTId = Sect.getSectionStyleId("EXIST");
//ObjectId objSectionStyleCPNTId = Sect.getSectionStyleId("CPNT");
//GroupPlotStyle objGroupPlotStyle = Sect.getGroupPlotStyle("WALL");
//SampleLineStyle objSampleLineStyle = Sect.getSampleLineStyle("Standard");
//SectionLabelSetStyle objSampleLabelSetStyle = Sect.getSampleLineLabelStyle("Standard");
double dblLen = objAlign.Length;
Sect.removeSampleLineGroups(objAlign.ObjectId);
string strLayer = string.Format("{0}-SEC", objAlign.Name);
Layer.manageLayers(strLayer);
ObjectId idSLG = Sect.addSampleLineGroupAndSampleLines(objAlign.ObjectId, "SLG-1");
idSLG.removeSampledSurfaces();
ObjectIdCollection idSurfaces = new ObjectIdCollection();
idSurfaces.Add(objSurfaceCPNT.ObjectId);
idSurfaces.Add(objSurfaceEXIST.ObjectId);
idSLG.addSurfaceToSample(idSurfaces);
Sect.addSections(objAlign.ObjectId, idSLG, 20.0, 20.0);
SampleLine objSampleLine = default(SampleLine);
Autodesk.Civil.DatabaseServices.Section objSection = default(Autodesk.Civil.DatabaseServices.Section);
ObjectIdCollection idsSampleLine = idSLG.getSampleLineIDs();
using (var tr = BaseObjs.startTransactionDb()) {
foreach (ObjectId idSampleLine in idsSampleLine)
{
objSampleLine = (SampleLine)tr.GetObject(idSampleLine, OpenMode.ForRead);
foreach (ObjectId idSection in objSampleLine.GetSectionIds())
{
objSection = (Section)tr.GetObject(idSection, OpenMode.ForWrite);
objSection.Layer = strLayer;
}
}
tr.Commit();
}
Autodesk.Civil.DatabaseServices.Styles.SectionViewStyle objSectionViewStyle = default(Autodesk.Civil.DatabaseServices.Styles.SectionViewStyle);
try {
objSectionViewStyle = Sect_Style.getSectionViewStyle("WALL");
}
catch (System.Exception) {
objSectionViewStyle = Sect_Style.getSectionViewStyle("Standard");
}
SectionViewBandSetStyle objSectionViewBandStyleSet = Sect_Style.getSectionViewBandSetStyle("Standard");
double dblOffX = 0;
double dblOffY = 0;
bool boolFirstPass = true;
//Dim objStationRange As New StationRange
//With objStationRange
// .UseSampleIncrements = True
// .SampleAtHighLowPoints = False
// .SampleAtHorizontalGeometryPoints = False
// .SampleAtSuperelevationCriticalStations = False
// .SampleAtRangeEnd = True
// .SampleAtRangeStart = True
// .StartRangeAtAlignmentStart = True
// .EndRangeAtAlignmentEnd = True
// .StartRange = 0.0
// .EndRange = dblLen - 1
// .IncrementTangent = 50.0
// .SwathWidthLeft = 20.0
// .SwathWidthRight = 20.0
// .SampleLineDefaultDirection = DirectionFromType.DirectionFromBaseAlignment
//End With
//objStationRange.SampleLineStyle = objSampleLineStyle
//objSLG.SampleLines.AddByStationRange("SL-1", SampleLineDuplicateActionType.SampleLineDuplicateActionOverwrite, objStationRange)
PromptStatus ps = default(PromptStatus);
Point3d pnt3dBase = default(Point3d);
try {
BaseObjs.acadActivate();
pnt3dBase = UserInput.getPoint("Select Insertion Point for Sections", out ps, osMode: 0);
}
catch (System.Exception) {
return;
}
SectionView objSectionView = null;
Point3d pnt3dIns = default(Point3d);
using (var tr1 = BaseObjs.startTransactionDb()) {
int j = 0;
for (int i = 0; i < idsSampleLine.Count; i += 5)
{
objSampleLine = (SampleLine)tr1.GetObject(idsSampleLine[i], OpenMode.ForRead);
//dblPntIns(0) = pnt3dBase.X + i / 5 * dblOffX
int k = -1;
while (j < idsSampleLine.Count)
{
k++;
pnt3dIns = new Point3d(pnt3dBase.X + i / 5 * dblOffX, pnt3dBase.Y + k * dblOffY, 0.0);
try {
ObjectId idSectionView = SectionView.Create("SV" + Convert.ToString(j), idsSampleLine[i], pnt3dIns);
objSectionView = (SectionView)tr1.GetObject(idSectionView, OpenMode.ForWrite);
objSectionView.OffsetLeft = 20.0;
objSectionView.OffsetRight = 20.0;
objSectionView.StyleId = objSectionViewStyle.ObjectId;
}
catch (Autodesk.AutoCAD.Runtime.Exception) {
}
if (boolFirstPass)
{
dblOffX = System.Math.Abs(objSectionView.OffsetLeft) + objSectionView.OffsetRight + 30;
dblOffY = (objSectionView.ElevationMax - objSectionView.ElevationMin) + 20;
boolFirstPass = false;
}
j++;
if (k == 4)
{
break;
}
}
}
tr1.Commit();
}
}
CreateProfileByDesign(string strName, Alignment objAlign)
{
List <PNT_DATA> varPNT_DATA = new List <PNT_DATA>();
Profile objProfile = default(Profile);
string strLayerName = null;
short i = 0;
Profile objProfileExist = Prof.getProfile(objAlign.ObjectId, "EXIST");
strLayerName = "PROFILE-" + strName;
ObjectId idLayer = Layer.manageLayers(strLayerName);
varPNT_DATA = fWall1.PNTSDESIGN;
Prof.removeProfile(objAlign.ObjectId, strName);
//Dim idProfileStyle As ObjectId = Prof_Style.getProfileStyle("WALL")
//Dim idStyleLabelSet As ObjectId = Prof_Style.getProfileLabelSetStyle("WALL")
ObjectId idProfileStyle = Prof_Style.getProfileStyle("Standard");
ObjectId idStyleLabelSet = Prof_Style.getProfileLabelSetStyle("Standard");
using (BaseObjs._acadDoc.LockDocument())
{
using (Transaction TR = BaseObjs.startTransactionDb())
{
objProfile = Prof.addProfileByLayout(strName, objAlign.ObjectId, idLayer, idProfileStyle, idStyleLabelSet);
TR.Commit();
}
}
double dblBenchWidth1 = Convert.ToDouble(fWall1.tbx_B1.Text);
double dblBenchWidth2 = Convert.ToDouble(fWall1.tbx_B2.Text);
double dblCurbHeight = Convert.ToDouble(fWall1.tbx_CF.Text);
double dblEasting = 0.0;
double dblNorthing = 0.0;
List <Point3d> pnt3dFL = new List <Point3d>();
List <Point3d> pnt3dTC = new List <Point3d>();
List <Point3d> pnt3dTOE = new List <Point3d>();
List <Point3d> pnt3dTS = new List <Point3d>();
List <Point3d> pnt3dTOP = new List <Point3d>();
short intSign = 0;
double dblElevFL = 0;
double dblElevTC = 0;
double dblElevTOE = 0;
double dblElevTS = 0;
double dblElevTOP = 0;
double dblElevEXIST = 0;
double dblElevDiff = 0;
double dblOffset = 0;
ObjectId idPoly3d = ObjectId.Null;
double dblSlope = Convert.ToDouble(fWall1.tbx_SG.Text);
Point3d pnt3d = default(Point3d);
double X = 0;
double X2 = 0;
double X1 = 0;
for (i = 0; i <= varPNT_DATA.Count - 1; i++)
{
dblElevFL = varPNT_DATA[i].z;
dblElevEXIST = objProfileExist.ElevationAt(varPNT_DATA[i].STA);
dblElevDiff = dblElevFL - dblElevEXIST;
dblOffset = varPNT_DATA[i].OFFSET;
if (dblOffset < 0)
{
intSign = -1;
dblOffset = dblOffset * -1;
}
else
{
intSign = 1;
}
if (dblElevFL > 0 & dblElevEXIST > 0)
{
dblElevTS = dblElevEXIST - dblBenchWidth2 * 0.02;
dblElevTC = dblElevFL + dblCurbHeight / 12;
objAlign.PointLocation(varPNT_DATA[i].STA, dblOffset * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevFL);
pnt3dFL.Add(pnt3d);
objAlign.PointLocation(varPNT_DATA[i].STA, (dblOffset - 0.1) * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTC);
pnt3dTC.Add(pnt3d);
dblElevDiff = dblElevFL - dblElevEXIST;
if (dblElevDiff < 0)
{
X = dblOffset - dblBenchWidth2;
X2 = (dblElevTS - dblElevTC - (0.02 * dblOffset)) / dblSlope;
X1 = X - X2;
if (X1 > dblBenchWidth1)
{
dblElevTOE = dblElevTC + X1 * 0.02;
objAlign.PointLocation(varPNT_DATA[i].STA, (dblOffset - X1) * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnt3dTOE.Add(pnt3d);
dblElevTS = dblElevTOE + dblSlope * X2;
objAlign.PointLocation(varPNT_DATA[i].STA, (dblOffset - (X1 + X2)) * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTS);
pnt3dTS.Add(pnt3d);
dblElevTOP = dblElevTS + 0.02 * dblBenchWidth2;
objAlign.PointLocation(varPNT_DATA[i].STA, (dblOffset - (X1 + X2 + dblBenchWidth2)) * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnt3dTOP.Add(pnt3d);
objProfile.PVIs.AddPVI(varPNT_DATA[i].STA, dblElevTOP);
}
else
{
dblElevTOE = dblElevTC + dblBenchWidth1 * 0.02;
objAlign.PointLocation(varPNT_DATA[i].STA, (dblOffset - dblBenchWidth1) * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnt3dTOE.Add(pnt3d);
dblElevTS = dblElevTOE + dblSlope * dblOffset - (dblBenchWidth1 + dblBenchWidth2);
objAlign.PointLocation(varPNT_DATA[i].STA, (dblOffset - (X1 + X2)) * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTS);
pnt3dTS.Add(pnt3d);
dblElevTOP = dblElevTS + 0.02 * dblBenchWidth2;
objAlign.PointLocation(varPNT_DATA[i].STA, 0.0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnt3dTOP.Add(pnt3d);
objProfile.PVIs.AddPVI(varPNT_DATA[i].STA, dblElevTOP);
}
}
else if (dblElevDiff > 0)
{
dblElevTOP = dblElevTC + 0.02 * dblOffset;
objAlign.PointLocation(varPNT_DATA[i].STA, 0.0, ref dblEasting, ref dblNorthing);
pnt3dTOP.Add(new Point3d(dblEasting, dblNorthing, dblElevTOP));
objProfile.PVIs.AddPVI(varPNT_DATA[i].STA, dblElevTOP);
}
}
}
try
{
ObjectIdCollection objEntIds = new ObjectIdCollection();
idPoly3d = Base_Tools45.Draw.addPoly3d(pnt3dFL);
objEntIds.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnt3dTC);
objEntIds.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnt3dTOE);
objEntIds.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnt3dTS);
objEntIds.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnt3dTOP);
objEntIds.Add(idPoly3d);
bool exists = false;
TinSurface objSurfaceCPNT = Surf.getTinSurface("CPNT-ON", out exists);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntIds, 0, 0, 0, 0);
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
objProfile.Layer = strLayerName;
}
BD(double B1Width, double B1Slope,
double B2Width, double B2Slope,
double gradeSlope, int interval,
string surfTAR, string surfDES,
int side = 0,
double elev = 0.0,
Polyline3d poly3d = null)
{
Boolean success = false;
Boolean exists = false;
Boolean doB1 = fSG.boolB1;
Boolean doB2 = fSG.boolB1;
List <Point3d> pnts3d = new List <Point3d>();
List <Point3d> pnts3dB1 = new List <Point3d>();
List <Point3d> pnts3dB2 = new List <Point3d>();
List <Point3d> pnts3dDL = new List <Point3d>();
List <Point3d> pnts3dRF = new List <Point3d>();
Vector3d v3d = Vector3d.XAxis;
Point3d pnt3dB;
BaseObjs.acadActivate();
ObjectId idPoly3dOrg = ObjectId.Null;
ObjectId idPoly3d = ObjectId.Null;
ObjectId idPoly = ObjectId.Null;
if (poly3d == null)
{
idPoly3dOrg = Select.getBrkLine("\nSelect 3D Polyline Reference: ");
}
else
{
idPoly3dOrg = poly3d.ObjectId;
}
if (idPoly3dOrg == ObjectId.Null)
{
return(false);
}
ResultBuffer rb = idPoly3dOrg.getXData(apps.lnkBrks);
if (rb == null)
{
return(false);
}
TypedValue[] tvs = rb.AsArray();
List <ObjectId> idsCgPntRF = tvs.getObjectIdList();
List <ObjectId> idsCgPntM = null;
ObjectId idCgPnt = ObjectId.Null;
bool isClosed = idPoly3dOrg.checkIfClosed3d(false);
if (!isClosed)
{
Application.ShowAlertDialog("Design reference Breakline is not closed. Exiting...");
return(false);
}
Point3d pnt3dB1_Mb = Pub.pnt3dO, pnt3dB2_Mb = Pub.pnt3dO, pnt3dDL_Mb = Pub.pnt3dO, pnt3dRF_Mb = Pub.pnt3dO;
Point3d pnt3dB1_Me = Pub.pnt3dO, pnt3dB2_Me = Pub.pnt3dO, pnt3dDL_Me = Pub.pnt3dO, pnt3dRF_Me = Pub.pnt3dO;
Point3d pnt3dX = Pub.pnt3dO, pnt3dXA = Pub.pnt3dO, pnt3dXB = Pub.pnt3dO;
uint pntNum = 0;
int s = 0;
double angle = 0.0, deflc = 0.0, delta = 0.0, slopeChk = 0.0;
List <ANG_PT_PROP> angPtProps = new List <ANG_PT_PROP>();
ANG_PT_PROP angPtProp = null;
try
{
using (BaseObjs._acadDoc.LockDocument())
{
pnts3d = idPoly3dOrg.getCoordinates3dList();
if (side == 0)
{
side = Geom.getSide(pnts3d);
}
angPtProps = pnts3d.getPoly3dAngPtProps();
int k = angPtProps.Count;
for (int i = 0; i < k; i++)
{
angPtProp = angPtProps[i];
pnt3dB = angPtProp.BEG; //last point = first point
deflc = angPtProp.ANG_DEFLC;
if (i == 0)
{
pnts3dRF.Add(pnt3dB); //add begin point
}
angle = getMidDeltaDirection(side, deflc, angPtProp.DIR_SEG1, angPtProp.DIR_SEG2, out s);
if (s == 0)
{
if (surfTAR == "")
{
pnt3dDL_Mb = getTargetElevation(elev, pnt3dB, angle, gradeSlope);
}
else
{
v3d = new Vector3d(sMath.Cos(angle), sMath.Sin(angle), -gradeSlope);
pnt3dDL_Mb = getSlopeIntercept(surfTAR, pnt3dB, gradeSlope, v3d);
}
pnts3dDL.Add(pnt3dDL_Mb);
idCgPnt = pnt3dDL_Mb.setPoint(out pntNum);
BaseObjs.updateGraphics();
idsCgPntM = new List <ObjectId> {
idsCgPntRF[i], idCgPnt
};
idPoly3d = BrkLine.makeBreakline(apps.lnkSLP, "cmdBD", out idPoly, idsCgPntM);
BaseObjs.updateGraphics();
}
else if (s == -2 || s == 4)
{
getToeIntercept(side, angPtProp, surfTAR, elev, gradeSlope, doB1, B1Width, B1Slope, doB2, B2Width, B2Slope, ref pnt3dDL_Mb, ref pnt3dXA, ref pnt3dXB);
if (i == 0)
{
pnt3dDL_Me = pnt3dXB;
}
else
{
pnts3dRF.Add(pnt3dXB);
pnt3dXB.setPoint(out pntNum, "CPNT-ON");
BaseObjs.updateGraphics();
}
slopeChk = pnt3dDL_Mb.getSlope(pnt3dXB);
Debug.Print(slopeChk.ToString("0.0000"));
pnts3dRF.Add(pnt3dB); //add RF Angle point
pnts3dRF.Add(pnt3dXA);
pnt3dXA.setPoint(out pntNum, "CPNT-ON");
BaseObjs.updateGraphics();
slopeChk = pnt3dDL_Mb.getSlope(pnt3dXA);
Debug.Print(slopeChk.ToString("0.0000"));
idCgPnt = pnt3dDL_Mb.setPoint(out pntNum, "CPNT-ON");
BaseObjs.updateGraphics();
idsCgPntM = new List <ObjectId> {
idsCgPntRF[i], idCgPnt
};
pnts3dDL.Add(pnt3dDL_Mb);
idPoly3d = BrkLine.makeBreakline(apps.lnkSLP, "cmdBD", out idPoly, idsCgPntM);
BaseObjs.updateGraphics();
}
else if (s == 2 || s == -4)
{
pnts3dRF.Add(pnt3dB);
double anglePerp1 = angPtProp.DIR_SEG1 + PI / 2 * -side;
double anglePerp2 = angPtProp.DIR_SEG2 + PI / 2 * -side;
Vector2d v2d1 = new Vector2d(sMath.Cos(anglePerp1), sMath.Sin(anglePerp1));
Vector2d v2d2 = new Vector2d(sMath.Cos(anglePerp2), sMath.Sin(anglePerp2));
delta = v2d1.GetAngleTo(v2d2);
List <double> angles = new List <double>();
angles.Add(anglePerp1);
double angleX = anglePerp1 + delta / 4 * side;
angles.Add(angleX);
angles.Add(angle);
angleX = angle + delta / 4 * side;
angles.Add(angleX);
angles.Add(anglePerp2);
foreach (double ang in angles)
{
angle = ang;
if (surfTAR != "")
{
v3d = new Vector3d(sMath.Cos(angle), sMath.Sin(angle), -gradeSlope);
pnt3dDL_Mb = getSlopeIntercept(surfTAR, pnt3dB, gradeSlope, v3d);
}
else
{
pnt3dDL_Mb = getTargetElevation(elev, pnt3dB, angle, gradeSlope);
}
pnts3dDL.Add(pnt3dDL_Mb);
idCgPnt = pnt3dDL_Mb.setPoint(out pntNum, "CPNT-ON");
BaseObjs.updateGraphics();
idsCgPntM = new List <ObjectId> {
idsCgPntRF[i], idCgPnt
};
idPoly3d = BrkLine.makeBreakline(apps.lnkSLP, "cmdBD", out idPoly, idsCgPntM);
BaseObjs.updateGraphics();
}
}
}
pnts3dDL.Add(pnts3dDL[0]); //complete point list with first point - for closure
if (pnt3dRF_Me != Pub.pnt3dO)
{
pnts3dRF.Add(pnt3dRF_Me); //point on RF opposite DL back - first mid delta
pnt3dRF_Me.setPoint(out pntNum, "CPNT-ON");
BaseObjs.updateGraphics();
}
pnts3dRF.Add(pnts3dRF[0]); //complete point list with first point - for closure
}
}
catch (SystemException ex)
{
BaseObjs.writeDebug(ex.Message + " cmdBD.cs: line: 244");
success = false;
}
ObjectId idPoly3dX = ObjectId.Null;
ObjectIdCollection idsPoly3dX = new ObjectIdCollection();
tvs = new TypedValue[13];
tvs.SetValue(new TypedValue(1001, "lnkSLP"), 0);
using (BaseObjs._acadDoc.LockDocument())
{
try
{
idPoly3dOrg.handOverPoly3d2(pnts3dRF);
Handle hB1;
if (pnts3dB1.Count > 0)
{
idPoly3dX = pnts3dB1.addPoly3d("CPNT-BRKLINE"); //Lower Bench
idsPoly3dX.Add(idPoly3dX);
hB1 = idPoly3dX.getHandle();
}
else
{
B1Width = 0.0;
B1Slope = 0.0;
hB1 = "0".stringToHandle();
}
tvs.SetValue(new TypedValue(1000, B1Width), 1);
tvs.SetValue(new TypedValue(1000, B1Slope), 2);
tvs.SetValue(new TypedValue(1005, hB1), 3);
Handle hB2;
if (pnts3dB2.Count > 0)
{
idPoly3dX = pnts3dB2.addPoly3d("CPNT-BRKLINE"); //Top of Slope/Upper Bench
idsPoly3dX.Add(idPoly3dX);
hB2 = idPoly3dX.getHandle();
}
else
{
B2Width = 0.0;
B2Slope = 0.0;
hB2 = "0".stringToHandle();
}
tvs.SetValue(new TypedValue(1000, B2Width), 4);
tvs.SetValue(new TypedValue(1000, B2Slope), 5);
tvs.SetValue(new TypedValue(1005, hB2), 6);
Handle hDL;
idPoly3dX = pnts3dDL.addPoly3d("CPNT-BRKLINE"); //Top of Slope/Daylight (if no upper bench)
idsPoly3dX.Add(idPoly3dX);
hDL = idPoly3dX.getHandle();
tvs.SetValue(new TypedValue(1000, gradeSlope), 7);
tvs.SetValue(new TypedValue(1070, side), 8);
tvs.SetValue(new TypedValue(1000, interval), 9);
tvs.SetValue(new TypedValue(1005, hDL), 10);
tvs.SetValue(new TypedValue(1000, surfTAR), 11);
tvs.SetValue(new TypedValue(1000, surfDES), 12);
idPoly3dOrg.setXData(tvs, apps.lnkSLP);
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " cmdBD.cs: line: 307");
}
}
if (idPoly3dX != ObjectId.Null)
{
DialogResult result;
result = MessageBox.Show(string.Format("Add Slope Breaklines to Design Surface? \nYes to add to surface: {0}\nNo to keep Breaklines, but not add to surface.\nCancel to dispose of Breaklines.", surfDES),
"Slope Breaklines",
System.Windows.Forms.MessageBoxButtons.YesNoCancel);
switch (result)
{
case DialogResult.Yes:
TinSurface surf = Surf.getTinSurface(surfDES, out exists);
surf.BreaklinesDefinition.AddStandardBreaklines(idsPoly3dX, 1.0, 1.0, 0.0, 0.0);
success = true;
break;
case DialogResult.No:
success = true;
break;
case DialogResult.Cancel:
success = false;
break;
}
}
else
{
success = false;
}
return(success);
}
LocateCurb4(string strName, Alignment objAlignPL, Alignment objAlignRF)
{
bool success = false;
Profile objProfilePL = default(Profile);
Profile objProfileRF = default(Profile);
double B1 = double.Parse(fWall4.tbx_B1.Text);
double B2 = double.Parse(fWall4.tbx_B2.Text);
double S0 = double.Parse(fWall4.tbx_S0.Text);
double S1 = double.Parse(fWall4.tbx_S1.Text);
double S2 = double.Parse(fWall4.tbx_S2.Text);
double SG = double.Parse(fWall4.tbx_SG.Text);
double CF = double.Parse(fWall4.tbx_CF.Text);
double CV = 0;
double CH = 0;
List <Point3d> pnts3dRF = new List <Point3d>();
List <Point3d> pnts3dFL = new List <Point3d>();
List <Point3d> pnts3dTC = new List <Point3d>();
List <Point3d> pnts3dTOE = new List <Point3d>();
List <Point3d> pnts3dTOP = new List <Point3d>();
List <Point3d> pnts3dPL = new List <Point3d>();
double dblOffsetPL = 0.0, dblOffsetRF = 0.0, dblEasting = 0.0, dblNorthing = 0.0;
double dblElevRF = 0, dblElevRFs = 0, dblElevFL = 0, dblElevBC = 0, dblElevTOE = 0, dblElevTOP = 0, dblElevPL = 0, dblElevDiff = 0;
double dblStationRF = 0, dblStationPL = 0;
double XT = 0, X0 = 0, X1 = 0, X2 = 0, dblDX = 0, dblDY = 0;
bool boolMakeTempSurface = false;
try
{
int intSign = fWall4.Side;
List <double> dblStationsFinal = new List <double>();
dblStationsFinal = fWall4.Stations;
if ((dblStationsFinal.Count == 0))
{
return(false);
}
else
{
objProfileRF = Prof.getProfile(objAlignRF.ObjectId, strName);
objProfilePL = Prof.getProfile(objAlignPL.ObjectId, "EXIST");
}
Point3d pnt3dBeg = default(Point3d);
Point3d pnt3dEnd = default(Point3d);
bool boolStart = false;
bool boolDone = false;
for (int i = 0; i < dblStationsFinal.Count; i++)
{
dblStationRF = dblStationsFinal[i];
//CURRENT STATION ON REF
Debug.Print(dblStationRF.ToString());
dblEasting = 0;
dblNorthing = 0;
if (System.Math.Abs(dblStationRF - objAlignRF.StartingStation) < 0.1)
{
dblStationRF = Base_Tools45.Math.roundUP2(objAlignRF.StartingStation);
}
if (System.Math.Abs(dblStationRF - objAlignRF.EndingStation) < 0.1)
{
dblStationRF = Base_Tools45.Math.roundDown2(objAlignRF.EndingStation);
}
try
{
objAlignRF.PointLocation(dblStationRF, 0.0, ref dblEasting, ref dblNorthing);
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
}
try
{
objAlignPL.StationOffset(dblEasting, dblNorthing, ref dblStationPL, ref dblOffsetPL);
// CORRESPONDING STATION ON PL
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
dblStationPL = 0.0;
}
//CHECK IF
if (System.Math.Round(dblStationRF, 1) >= System.Math.Round(objAlignRF.StartingStation, 1))
{
boolStart = true;
}
if (System.Math.Round(dblStationRF, 1) <= System.Math.Round(objAlignRF.EndingStation, 1))
{
boolDone = false;
}
if (boolStart == true & boolDone == false)
{
try
{
dblElevRF = objProfileRF.ElevationAt(dblStationRF);
//elevation on REF at current REF station
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
try
{
dblElevPL = objProfilePL.ElevationAt(Base_Tools45.Math.roundDown2(dblStationPL));
//elevation on PL at PL station corresponding to REF station
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
dblElevPL = 0;
}
//valid surface elevations for both RF and PL
if (dblElevRF > 0 & dblElevPL > 0)
{
dblElevTOP = dblElevPL - (B2 * S2);
//top of slope - always sloping away from PL
try
{
objAlignRF.PointLocation(dblStationRF, 0.0, ref dblEasting, ref dblNorthing);
//point location at RF align station corresponding to PL station
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
Point3d pnt3d = new Point3d(dblEasting, dblNorthing, dblElevRF);
pnts3dRF.Add(pnt3d);
dblElevDiff = dblElevRF - dblElevPL;
try
{
objAlignPL.StationOffset(dblEasting, dblNorthing, ref dblStationPL, ref dblOffsetPL);
//station and offset from PL to REF
}
catch (Autodesk.Civil.PointNotOnEntityException)
{
dblStationPL = 0.0;
}
//0 station means that the return station was outside limits
if (dblStationPL == 0)
{
pnt3dBeg = new Point3d(dblEasting, dblNorthing, 0.0);
//point location at REF align
dblStationPL = objAlignPL.EndingStation;
objAlignPL.PointLocation(objAlignPL.EndingStation, 0, ref dblEasting, ref dblNorthing);
pnt3dEnd = new Point3d(dblEasting, dblNorthing, 0.0);
//point location at end PL align
dblOffsetPL = pnt3dBeg.getDistance(pnt3dEnd);
//distance from REF to PL
}
XT = System.Math.Abs(dblOffsetPL);
if (CF != 0)
{
CV = CF / 12 + 0.021;
CH = CF / 12 / 4 + 0.5;
}
else
{
CV = 0;
CH = 0;
}
double SLOPE = 0.0;
//PL lower than REF - slope down
if (dblElevDiff >= 0)
{
SLOPE = SG * -1;
}
else
{
SLOPE = SG;
}
X1 = ((dblElevRF - dblElevPL) + CV + (XT - CH - B2) * SLOPE + (B2 * S2)) / (SLOPE - S1);
if (X1 < 0)
{
boolMakeTempSurface = true;
dblElevRFs = dblElevPL - (B2 * S2) - (XT - B2) * SLOPE;
dblDY = dblElevRFs - dblElevRF;
if (CV == 0)
{
if (SLOPE > 0)
{
if (S1 > 0)
{
X2 = XT - B2 + dblDY / (SLOPE - S1);
}
else
{
}
}
else
{
}
//dblElevPL = dblElevPL;
objAlignPL.PointLocation(dblStationPL, 0.0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevPL);
pnts3dPL.Add(pnt3d);
dblElevTOP = dblElevPL - (B2 * S2);
objAlignPL.PointLocation(dblStationPL, B2 * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnts3dTOP.Add(pnt3d);
dblElevTOE = dblElevPL - (B2 * S2) - (X2 * SLOPE);
objAlignPL.PointLocation(dblStationPL, (B2 + X2) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnts3dTOE.Add(pnt3d);
dblElevBC = dblElevTOE;
objAlignPL.PointLocation(dblStationPL, (B2 + X2) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevBC);
pnts3dTC.Add(pnt3d);
dblElevFL = dblElevRF + X1 * S0;
objAlignPL.PointLocation(dblStationPL, (XT - X1) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevFL);
pnts3dFL.Add(pnt3d);
}
else if (CV > 0)
{
dblDX = (dblDY - (B1 * S1) - CV - (CH + B1) * S0) / (SLOPE - S0);
//dblElevPL = dblElevPL;
objAlignPL.PointLocation(dblStationPL, 0.0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevPL);
pnts3dPL.Add(pnt3d);
dblElevTOP = dblElevPL - (B2 * S2);
objAlignPL.PointLocation(dblStationPL, B2 * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnts3dTOP.Add(pnt3d);
dblElevTOE = dblElevTOP - ((X2 + dblDX) * SLOPE);
objAlignPL.PointLocation(dblStationPL, (B2 + X2 + dblDX) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnts3dTOE.Add(pnt3d);
dblElevBC = dblElevTOE - (B1 * S1);
objAlignPL.PointLocation(dblStationPL, (B2 + X2 + dblDX + B1) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevBC);
pnts3dTC.Add(pnt3d);
dblElevFL = dblElevBC - CV;
objAlignPL.PointLocation(dblStationPL, (B2 + X2 + dblDX + B1 + CH) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevFL);
pnts3dFL.Add(pnt3d);
}
}
else if (X1 >= 0)
{
if (X1 > B1)
{
if (S0 == S1)
{
X2 = XT - CH - X1 - B2;
//all good we use B1
}
else if (S0 > S1)
{
dblDX = ((dblElevRF - dblElevPL) + CV + (B1 * S1) + (B2 * S2) + (XT - CH - B1 - B2) * SLOPE) / (SLOPE - S0);
X2 = XT - dblDX - CH - B1 - B2;
}
else if (S0 < S1)
{
dblDX = ((dblElevRF - dblElevPL) + CV + (B1 * S1) + (B2 * S2) + (XT - CH - B1 - B2) * SLOPE) / (SLOPE - S0);
X2 = XT - dblDX - CH - B1 - B2;
}
}
else if (X1 < B1)
{
if (S0 > S1)
{
dblDX = ((dblElevRF - dblElevPL) + CV + (B1 * S1) + (XT - CH - B1 - B2) * SLOPE + (B2 * S2)) / (S0 - SLOPE);
X2 = XT - CH - B1 - B2 + dblDX;
}
else if (S0 == S1)
{
X2 = XT - CH - X1 - B2;
//B1 is used no change necessary
}
else if (S0 < S1)
{
dblDX = ((dblElevRF - dblElevPL) + CV + (B1 * S1) + (XT - CH - B1 - B2) * SLOPE + (B2 * S2)) / (S0 - SLOPE);
X2 = XT - CH - B1 - B2 + dblDX;
}
}
//dblElevPL = dblElevPL;
objAlignPL.PointLocation(dblStationPL, 0.0, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevPL);
pnts3dPL.Add(pnt3d);
dblElevTOP = dblElevPL - (B2 * S2);
objAlignPL.PointLocation(dblStationPL, B2 * intSign, ref dblEasting, ref dblNorthing);
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOP);
pnts3dTOP.Add(pnt3d);
dblElevTOE = dblElevTOP - (X2 * SLOPE);
objAlignPL.PointLocation(dblStationPL, (B2 + X2) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevTOE);
pnts3dTOE.Add(pnt3d);
dblElevBC = dblElevTOE - (B1 * S1);
objAlignPL.PointLocation(dblStationPL, (B2 + X2 + B1) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevBC);
pnts3dTC.Add(pnt3d);
dblElevFL = dblElevBC - CV;
objAlignPL.PointLocation(dblStationPL, (B2 + X2 + B1 + CH) * intSign, ref dblEasting, ref dblNorthing);
//point perp to PL
pnt3d = new Point3d(dblEasting, dblNorthing, dblElevFL);
pnts3dFL.Add(pnt3d);
}
}
}
}
ObjectId idPoly3d = ObjectId.Null;
using (BaseObjs._acadDoc.LockDocument())
{
using (Transaction TR = BaseObjs.startTransactionDb())
{
try
{
ObjectIdCollection objEntIDs = new ObjectIdCollection();
//Dim intXDataType As List(Of int) = New List(Of int)(2)
//Dim varXDataVal As List(Of Object) = New List(Of Object)(2)
string strLayer = null;
if (boolMakeTempSurface)
{
strLayer = "CPNT-BRKLINE-TEMP";
}
else
{
strLayer = "CPNT-BRKLINE";
}
Layer.manageLayers(strLayer);
//intXDataType.Add(1001) : varXDataVal.Add("PL")
TypedValue[] tvs = new TypedValue[2];
tvs[0] = new TypedValue(1001, "PL");
if (boolMakeTempSurface == false)
{
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dRF, strLayer, 6);
tvs[1] = new TypedValue(1000, "REF");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dFL, strLayer, 1);
tvs[1] = new TypedValue(1000, "FL");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
}
else
{
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dFL, strLayer, 1);
tvs[1] = new TypedValue(1000, "FL");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
}
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTC, strLayer, 2);
tvs[1] = new TypedValue(1000, "TC");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTOE, strLayer, 3);
tvs[1] = new TypedValue(1000, "TOE");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dTOP, strLayer, 4);
tvs[1] = new TypedValue(1000, "TOP");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
idPoly3d = Base_Tools45.Draw.addPoly3d(pnts3dPL, strLayer, 5);
tvs[1] = new TypedValue(1000, "PL");
idPoly3d.setXData(tvs, "PL");
objEntIDs.Add(idPoly3d);
ObjectIdCollection objEntEndIDs = wdp.makeEndBrklinesORG(strLayer, objEntIDs, false);
bool exists = false;
if (boolMakeTempSurface == false)
{
TinSurface objSurfaceCPNT = Surf.getTinSurface("CPNT-ON", out exists);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntIDs, 1, 0, 0, 0);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntEndIDs, 1, 0, 0, 0);
}
else
{
TinSurface objSurfaceTemp = Surf.getTinSurface("TEMP", out exists);
objSurfaceTemp.BreaklinesDefinition.AddStandardBreaklines(objEntIDs, 1, 0, 0, 0);
objSurfaceTemp.BreaklinesDefinition.AddStandardBreaklines(objEntEndIDs, 1, 0, 0, 0);
}
}
catch (Autodesk.AutoCAD.Runtime.Exception ex)
{
Autodesk.AutoCAD.ApplicationServices.Core.Application.ShowAlertDialog(ex.ToString());
}
TR.Commit();
}
}
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
MessageBox.Show("LocateCurb");
return(false);
}
return(success);
}
balanceSite()
{
double dblSiteAdjust = 0;
Point3d pnt3dMove0 = Point3d.Origin;
TinSurface objSurfaceSG = Surf.getTinSurface("SG", out exists);
TinSurface objSurfaceOX = Surf.getTinSurface("OX", out exists);
dblSiteAdjust = double.Parse(this.tboxAdjSurface.Text);
varDataCurrent.SITE_ADJUST = dblSiteAdjust;
updateDictionary(varDataCurrent);
Point3d pnt3dMoveX = new Point3d(0, 0, dblSiteAdjust);
Matrix3d mtx3d = Matrix3d.Displacement(pnt3dMoveX - pnt3dMove0);
objSurfaceSG.TransformBy(mtx3d);
objSurfaceOX.TransformBy(mtx3d);
ewtbe.reTest();
ewmsv.updateVolSurface("EXIST", "BOT");
ewmsv.updateVolSurface("BOT", "SG");
// ERROR: Not supported in C#: OnErrorStatement
ObjectId idSurfaceCUT = Surf.getSurface("VOL_EXIST_BOT", out exists);
if (idSurfaceCUT.IsNull)
{
ewmsv.updateVolSurface("EXIST", "BOT");
}
ObjectId idSurfaceFILL = Surf.getSurface("VOL_BOT_SG", out exists);
if (idSurfaceFILL.IsNull)
{
ewmsv.updateVolSurface("BOT", "SG");
}
TinVolumeSurface objSurfaceCUT = (TinVolumeSurface)idSurfaceCUT.getEnt();
dblVOL_EXIST_BOT_CUT = objSurfaceCUT.GetVolumeProperties().UnadjustedCutVolume / 27;
dblVOL_EXIST_BOT_FILL = objSurfaceCUT.GetVolumeProperties().UnadjustedFillVolume / 27;
TinVolumeSurface objSurfaceFILL = (TinVolumeSurface)idSurfaceFILL.getEnt();
dblVOL_BOT_SG_CUT = objSurfaceFILL.GetVolumeProperties().UnadjustedCutVolume / 27;
dblVOL_BOT_SG_FILL = objSurfaceFILL.GetVolumeProperties().UnadjustedFillVolume / 27;
dblVOL_CUT_TOT = dblVOL_EXIST_BOT_CUT + dblVOL_BOT_SG_CUT;
//Gross Cut put in spreadsheet
dblVOL_FILL_TOT = dblVOL_EXIST_BOT_FILL + dblVOL_BOT_SG_FILL;
//Gross Fill put in spreadsheet
dblVOL_CUT_SHRINK = (dblVOL_CUT_TOT * dblSHRINKAGE_FACTOR * -1);
dblVOL_CUT_NET = dblVOL_CUT_ADJ_NET + dblVOL_CUT_TOT + dblVOL_CUT_SHRINK;
dblVOL_FILL_NET = dblVOL_FILL_ADJ_NET + dblVOL_FILL_TOT;
dblSG_MEAN_ELEV = objSurfaceSG.GetGeneralProperties().MeanElevation;
dblVOL_NET = (dblVOL_CUT_NET - dblVOL_FILL_NET);
dblSITE_ADJUST = dblVOL_NET * 27 / dblAREA_SITE;
this.AdjustSurfaceSG.Text = string.Format("{0:#0.00", dblSG_MEAN_ELEV - dblSG_MEAN_ELEV0);
varDataCurrent.ITERATION = "C";
varDataCurrent.DATE = strDATE;
varDataCurrent.USER = strUSER;
varDataCurrent.AREA_SITE = dblAREA_SITE;
varDataCurrent.SG_MEAN_ELEV = dblSG_MEAN_ELEV;
varDataCurrent.VOL_CUT_TOT = dblVOL_CUT_TOT;
varDataCurrent.VOL_CUT_ADJ_NET = dblVOL_CUT_ADJ_NET;
varDataCurrent.VOL_CUT_SHRINK = dblVOL_CUT_SHRINK;
varDataCurrent.VOL_CUT_NET = dblVOL_CUT_NET;
varDataCurrent.VOL_FILL_TOT = dblVOL_FILL_TOT;
varDataCurrent.VOL_FILL_ADJ_NET = dblVOL_FILL_ADJ_NET;
varDataCurrent.VOL_FILL_NET = dblVOL_FILL_NET;
varDataCurrent.VOL_NET = dblVOL_NET;
varDataCurrent.SITE_ADJUST = dblSITE_ADJUST;
ewData = getDictData();
ewData.Add(varDataCurrent);
this.DG1.DataContext = ewData;
return;
}
wallBrlkinesToSurface(Alignment objAlignPL, Alignment objAlignRF, Alignment objAlignWall)
{
FEATUREDATA fDataW0 = new FEATUREDATA();
FEATUREDATA fDataW1 = new FEATUREDATA();
FEATUREDATA fDataW2 = new FEATUREDATA();
FEATUREDATA fDataW3 = new FEATUREDATA();
FEATUREDATA fDataG0 = new FEATUREDATA();
FEATUREDATA fDataGB = new FEATUREDATA();
bool exists = false;
try
{
TinSurface objSurfaceCPNT = Surf.getTinSurface("CPNT-ON", out exists);
string strLayer = null;
strLayer = string.Format("{0}-BRKLINE", objAlignPL.Name);
Layer.manageLayers(strLayer);
//-------------------------------------GUTTER BREAKLINES -------------------------------------------------------------------------------------------------------------------ADDED TO CPNT
ObjectIdCollection objEntsGutter = new ObjectIdCollection();
ObjectIdCollection objEntsEndsGutter = new ObjectIdCollection();
for (int i = 0; i < p.dGUTs.Count - 1; i++)
{
if (p.dGUTs[i]["W3"].Count > 1)
{
objEntsGutter.Add(wu.fData_3dPoly("W3", strLayer, p.dGUTs[i]["W3"], objAlignRF, objAlignPL));
objEntsGutter.Add(wu.fData_3dPoly("G0", strLayer, p.dGUTs[i]["G0"], objAlignRF, objAlignPL));
objEntsGutter.Add(wu.fData_3dPoly("GB", strLayer, p.dGUTs[i]["GB"], objAlignRF, objAlignPL));
objEntsEndsGutter = wdp.makeEndBrklinesWALL(strLayer, objEntsGutter, false);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntsEndsGutter, 0, 0, 0, 0);
}
}
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntsGutter, 0, 0, 0, 0);
//-------------------------------------WALL BREAKLINES------------------------------------------------------------------------------------------------------------------ NEW SURFACE - WALL
ObjectIdCollection objEntsWall = new ObjectIdCollection();
ObjectIdCollection objEntEndsWall = new ObjectIdCollection();
ObjectIdCollection objEntsWallCPNT = new ObjectIdCollection();
for (int i = 0; i < p.dWALLs.Count - 1; i++)
{
//TEST IS THERE ARE AT LEAST TWO POINTS
if (p.dWALLs[i]["W0"].Count > 1)
{
objEntsWall.Add(wu.fData_3dPoly("W0", strLayer, p.dWALLs[i]["W0"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W1", strLayer, p.dWALLs[i]["W1"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W2", strLayer, p.dWALLs[i]["W2"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W3", strLayer, p.dWALLs[i]["W3"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W4", strLayer, p.dWALLs[i]["W4"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W5", strLayer, p.dWALLs[i]["W5"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W6", strLayer, p.dWALLs[i]["W6"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W7", strLayer, p.dWALLs[i]["W7"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W8", strLayer, p.dWALLs[i]["W8"], objAlignRF, objAlignPL));
objEntsWall.Add(wu.fData_3dPoly("W9", strLayer, p.dWALLs[i]["W9"], objAlignRF, objAlignPL));
objEntsWallCPNT.Add(objEntsWall[0]);
objEntsWallCPNT.Add(objEntsWall[1]);
objEntsWallCPNT.Add(objEntsWall[2]);
objEntsWallCPNT.Add(objEntsWall[3]);
TinSurface objSurfaceWallCut = Surf.getTinSurface(Align.getAlignName("WALL") + "-CUT", out exists);
objSurfaceWallCut.BreaklinesDefinition.AddStandardBreaklines(objEntsWall, 0, 0, 0, 0);
objEntEndsWall = wdp.makeEndBrklinesWALL(strLayer, objEntsWall, true);
objSurfaceWallCut.BreaklinesDefinition.AddStandardBreaklines(objEntEndsWall, 0, 0, 0, 0);
//ADD END BREAKLINES
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntsWallCPNT, 0, 0, 0, 0);
}
}
//----------------------------------- WALL ENDS -------------------------------------------------------------------------------------------------------------------
double dblStaBeg = objAlignRF.StartingStation;
double dblStaEnd = objAlignRF.EndingStation;
double dblEasting = 0, dblNorthing = 0;
if (p.dWALLs[0]["W0"].ContainsKey((float)dblStaBeg))
{
List <Point3d> dblPntsBEG = new List <Point3d>();
fDataW0 = p.dWALLs[0]["W0"][(float)dblStaBeg];
fDataW1 = p.dWALLs[0]["W1"][(float)dblStaBeg];
fDataW2 = p.dWALLs[0]["W2"][(float)dblStaBeg];
fDataW3 = p.dWALLs[0]["W3"][(float)dblStaBeg];
fDataG0 = p.dGUTs[0]["G0"][(float)dblStaBeg];
fDataGB = p.dGUTs[0]["GB"][(float)dblStaBeg];
objAlignRF.PointLocation(fDataW0.Station, fDataW0.Offset, ref dblEasting, ref dblNorthing);
dblPntsBEG.Add(new Point3d(dblEasting, dblNorthing, fDataW0.Elev));
objAlignRF.PointLocation(fDataW1.Station, fDataW1.Offset, ref dblEasting, ref dblNorthing);
dblPntsBEG.Add(new Point3d(dblEasting, dblNorthing, fDataW1.Elev));
objAlignRF.PointLocation(fDataW2.Station, fDataW2.Offset, ref dblEasting, ref dblNorthing);
dblPntsBEG.Add(new Point3d(dblEasting, dblNorthing, fDataW2.Elev));
objAlignRF.PointLocation(fDataW3.Station, fDataW3.Offset, ref dblEasting, ref dblNorthing);
dblPntsBEG.Add(new Point3d(dblEasting, dblNorthing, fDataW3.Elev));
objAlignRF.PointLocation(fDataG0.Station, fDataG0.Offset, ref dblEasting, ref dblNorthing);
dblPntsBEG.Add(new Point3d(dblEasting, dblNorthing, fDataG0.Elev));
objAlignPL.PointLocation(fDataGB.Station, fDataGB.Offset, ref dblEasting, ref dblNorthing);
dblPntsBEG.Add(new Point3d(dblEasting, dblNorthing, fDataGB.Elev));
//Wall_Forms.fWall1.PntsWallCutBeg = dblPntsBEG;
}
int j = p.dWALLs.Count - 1;
if (j > 1)
{
if (p.dWALLs[j]["W0"].ContainsKey((float)dblStaEnd))
{
List <Point3d> dblPntsEND = new List <Point3d>();
objAlignRF.PointLocation(fDataW0.Station, fDataW0.Offset, ref dblEasting, ref dblNorthing);
dblPntsEND.Add(new Point3d(dblEasting, dblNorthing, fDataW0.Elev));
objAlignRF.PointLocation(fDataW1.Station, fDataW1.Offset, ref dblEasting, ref dblNorthing);
dblPntsEND.Add(new Point3d(dblEasting, dblNorthing, fDataW1.Elev));
objAlignRF.PointLocation(fDataW2.Station, fDataW2.Offset, ref dblEasting, ref dblNorthing);
dblPntsEND.Add(new Point3d(dblEasting, dblNorthing, fDataW2.Elev));
objAlignRF.PointLocation(fDataW3.Station, fDataW3.Offset, ref dblEasting, ref dblNorthing);
dblPntsEND.Add(new Point3d(dblEasting, dblNorthing, fDataW3.Elev));
objAlignRF.PointLocation(fDataG0.Station, fDataG0.Offset, ref dblEasting, ref dblNorthing);
dblPntsEND.Add(new Point3d(dblEasting, dblNorthing, fDataG0.Elev));
objAlignPL.PointLocation(fDataGB.Station, fDataGB.Offset, ref dblEasting, ref dblNorthing);
dblPntsEND.Add(new Point3d(dblEasting, dblNorthing, fDataGB.Elev));
//Wall_Forms.wForms.fWall1.PntsWallCutEnd = dblPntsEND;
}
}
//-------------------------------------REGULARS----------------------------------------------------------------------------------------------------------------------------------- ADD TO CPNT
ObjectIdCollection objEntsNOM = new ObjectIdCollection();
ObjectIdCollection objEntEnds = new ObjectIdCollection();
objEntsNOM.Add(wu.fData_3dPoly("RF", strLayer, p.dNOM["RF"], objAlignRF, objAlignPL));
objEntsNOM.Add(wu.fData_3dPoly("RF", strLayer, p.dNOM["FL"], objAlignRF, objAlignPL));
objEntsNOM.Add(wu.fData_3dPoly("RF", strLayer, p.dNOM["TC"], objAlignRF, objAlignPL));
objEntsNOM.Add(wu.fData_3dPoly("RF", strLayer, p.dNOM["TOE"], objAlignRF, objAlignPL));
objEntsNOM.Add(wu.fData_3dPoly("RF", strLayer, p.dNOM["TOP"], objAlignRF, objAlignPL));
objEntsNOM.Add(wu.fData_3dPoly("RF", strLayer, p.dNOM["PL"], objAlignRF, objAlignPL));
objEntEnds = wdp.makeEndBrklines(strLayer, objEntsNOM);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntsNOM, 0, 0, 0, 0);
objSurfaceCPNT.BreaklinesDefinition.AddStandardBreaklines(objEntEnds, 0, 0, 0, 0);
}
catch (Autodesk.AutoCAD.Runtime.Exception)
{
}
}
public static Boolean SG(double slope, string surfTAR, string surfDES)
{
Boolean boolDoFirst = true;
Boolean success = false;
List <Point3d> pnts3d = new List <Point3d>();
List <Point3d> pnts3dB1 = new List <Point3d>();
List <Point3d> pnts3dB2 = new List <Point3d>();
List <Point3d> pnts3dD = new List <Point3d>();
List <Point3d> pnts3dR = new List <Point3d>();
Point3d pnt3dA, pnt3dB, pnt3dC;
BaseObjs.acadActivate();
ObjectId idPoly3d = Select.getBrkLine("\nSelect 3D Polyline Reference: ");
try
{
if (idPoly3d != ObjectId.Null)
{
pnts3d = idPoly3d.getCoordinates3dList();
int intSide = SG_Utility.getSide(pnts3d);
if (pnts3d.Count > 2)
{
for (int i = 0; i < pnts3d.Count - 2; i++)
{
pnt3dA = pnts3d[i + 0];
pnt3dB = pnts3d[i + 1];
pnt3dC = pnts3d[i + 2];
success = setupSlope(intSide, pnt3dA, pnt3dB, pnt3dC, slope, ref boolDoFirst, surfTAR, surfDES, ref pnts3dB1, ref pnts3dB2, ref pnts3dD, ref pnts3dR);
}
pnt3dB = pnts3d[pnts3d.Count - 2];
pnt3dC = pnts3d[pnts3d.Count - 1];
success = setupSlope(intSide, pnt3dB, pnt3dC, slope, ref boolDoFirst, surfTAR, surfDES, ref pnts3dB1, ref pnts3dB2, ref pnts3dD, ref pnts3dR);
}
else
{
pnt3dA = pnts3d[0];
pnt3dB = pnts3d[1];
success = setupSlope(intSide, pnt3dA, pnt3dB, slope, ref boolDoFirst, surfTAR, surfDES, ref pnts3dB1, ref pnts3dB2, ref pnts3dD, ref pnts3dR);
}
}
}
catch (SystemException)
{
success = false;
}
ObjectId idPoly3dX = ObjectId.Null;
ObjectIdCollection idsPoly3dX = new ObjectIdCollection();
using (BaseObjs._acadDoc.LockDocument())
{
try
{
//idPoly3dX = pnts3dR.addPoly3d("CPNT-BRKLINE");
//idsPoly3dX.Add(idPoly3dX);
idPoly3dX = pnts3dB1.addPoly3d("CPNT-BRKLINE");
idsPoly3dX.Add(idPoly3dX);
idPoly3dX = pnts3dB2.addPoly3d("CPNT-BRKLINE");
idsPoly3dX.Add(idPoly3dX);
idPoly3dX = pnts3dD.addPoly3d("CPNT-BRKLINE");
idsPoly3dX.Add(idPoly3dX);
}
catch (System.Exception ex)
{
MessageBox.Show(ex.ToString());
}
} bool exists = false;
if (idPoly3dX != ObjectId.Null)
{
DialogResult result;
result = MessageBox.Show("Add Slope Breaklines to Design Surface? \nYes to add to surface: " + surfDES
+ "\nNo to keep Breaklines, but not add to surface."
+ "\nCancel to dispose of Breaklines.",
"Slope Breaklines",
System.Windows.Forms.MessageBoxButtons.YesNoCancel);
switch (result)
{
case DialogResult.Yes:
TinSurface surf = (TinSurface)Surf.getTinSurface(surfDES, out exists);
surf.BreaklinesDefinition.AddStandardBreaklines(idsPoly3dX, 1.0, 1.0, 0.0, 0.0);
success = true;
break;
case DialogResult.No:
success = true;
break;
case DialogResult.Cancel:
success = false;
break;
}
}
else
{
success = false;
}
return(success);
}