insertCurve(ObjectId idAlign)
{
Alignment align = (Alignment)idAlign.getEnt();
AlignmentEntityCollection ents = align.Entities;
PromptStatus ps;
Point3d pnt3dPick = UserInput.getPoint("Select Curve PI", out ps, osMode: 1);
AlignmentEntity lineBefore = null;
AlignmentEntity lineAfter = null;
for (int i = 0; i < ents.Count; i++)
{
AlignmentEntity ent = ents[i];
if (ent.EntityType == AlignmentEntityType.Line)
{
AlignmentLine line = (AlignmentLine)ent;
if (line.EndPoint.IsEqualTo(pnt3dPick.Convert2d(BaseObjs.xyPlane), new Tolerance(.01, .01)))
{
lineBefore = line;
}
if (line.StartPoint.IsEqualTo(pnt3dPick.Convert2d(BaseObjs.xyPlane), new Tolerance(.01, .01)))
{
lineAfter = line;
}
}
}
AlignmentArc arc = ents.AddFreeCurve(lineBefore.EntityId, lineAfter.EntityId, 200.0, CurveParamType.Radius, false, CurveType.Compound);
List <AlgnEntData> algnEntData = sortAlignEnts(align);
fAlignEnts.updateForm(algnEntData);
fAlignEnts.AlignHandle = align.Handle;
Application.ShowModelessDialog(Application.MainWindow.Handle, fAlignEnts, false);
}
/// <summary>
/// Creates an AAlignmentEntity wraping an alignment entity.
/// </summary>
/// <param name="entity">Entity to be wrapped.</param>
/// <returns>A wrapper AAlignmentEntity object.</returns>
public static AAlignmentEntity WrapEntity(AlignmentEntity entity)
{
AAlignmentEntity wrapped = CreateWrapper(entity.EntityType);
wrapped.AssignEntity(entity);
return(wrapped);
}
public static List <AlignmentSubEntity> GetSubEntities(this AlignmentEntity entity)
{
var subEntities = new List <AlignmentSubEntity>();
for (int i = 0; i < entity.SubEntityCount; i++)
{
subEntities.Add(entity[i]);
}
return(subEntities);
}
getStationTargetAlign(double dblStaRF, double dblOffRR, Alignment objAlignRF, Alignment objAlignTAR)
{
AlignmentEntity objAlignEntRF = default(AlignmentEntity);
AlignmentArc objAlignEntArcRF = default(AlignmentArc);
AlignmentLine objAlignEntTanRF = default(AlignmentLine);
AlignmentEntity objAlignEntTAR = default(AlignmentEntity);
AlignmentArc objAlignEntArcTAR = default(AlignmentArc);
AlignmentLine objAlignEntTanTAR = default(AlignmentLine);
double dblAngEntRF = 0;
double dblAngEntTAR = 0;
double dblSkew = 0;
double dblOffRF = 0;
double dblStaTAR = 0;
objAlignEntRF = objAlignRF.Entities.EntityAtStation(dblStaRF);
if (objAlignEntRF.EntityType == AlignmentEntityType.Arc)
{
objAlignEntArcRF = (AlignmentArc)objAlignEntRF;
}
else if (objAlignEntRF.EntityType == AlignmentEntityType.Line)
{
objAlignEntTanRF = (AlignmentLine)objAlignEntRF;
}
Point2d pnt2dBEG = objAlignEntTanRF.StartPoint;
Point2d pnt2dEND = objAlignEntTanRF.EndPoint;
dblAngEntRF = pnt2dBEG.getDirection(pnt2dEND);
objAlignRF.DistanceToAlignment(dblStaRF, objAlignTAR, AlignmentSide.Both, ref dblOffRF, ref dblStaTAR);
objAlignEntTAR = objAlignTAR.Entities.EntityAtStation(dblStaTAR);
if (objAlignEntTAR.EntityType == AlignmentEntityType.Arc)
{
objAlignEntArcTAR = (AlignmentArc)objAlignEntRF;
}
else if (objAlignEntTAR.EntityType == AlignmentEntityType.Line)
{
objAlignEntTanTAR = (AlignmentLine)objAlignEntTAR;
}
pnt2dBEG = objAlignEntTanTAR.StartPoint;
pnt2dEND = objAlignEntTanTAR.EndPoint;
dblAngEntTAR = pnt2dBEG.getDirection(pnt2dEND);
dblSkew = dblAngEntTAR - dblAngEntRF;
//dblStaTAR = dblStaRF * System.Math.Cos(dblSkew)
return(dblStaTAR);
}
/// <summary>
///
/// </summary>
/// <param name="align"></param>
private void enumerateEntsByOrder(Alignment align)
{
AlignmentEntityCollection ents = align.Entities;
for (int i = 0; i < ents.Count; i++)
{
AlignmentEntity ent = ents.GetEntityByOrder(i);
BaseObjs.write(string.Format("\n.. Entity Sequence: {0}", i));
writeAlignData(ent);
}
}
private void PrintSubEntities(AlignmentEntity entity)
{
for (int i = 0; i < entity.SubEntityCount; i++)
{
string message = "\n";
message += $" Subentity {i + 1}: " +
$"\n Type = {entity[i].GetType()}" +
$"\n StartStation = {entity[i].StartStation}" +
$"\n EndStation = {entity[i].EndStation}";
Active.WriteMessage(message);
}
}
public void WrapEntityCorrectly()
{
Document testDoc = getTestDocument();
using (Transaction tr = testDoc.StartTransaction())
{
AlignmentEntity entity = getTestEntity(testDoc);
AAlignmentEntity wrapper = AlignmentEntityWrapperFactory.WrapEntity(entity);
Assert.IsTrue(wrapper.IsValid, "Entity not wrapped correctly.");
}
}
private void enumerateEntitiesByOrder(Alignment alignment)
{
AlignmentEntityCollection entities = alignment.Entities;
for (int i = 0; i < entities.Count; i++)
{
AlignmentEntity entity = entities.GetEntityByOrder(i);
write("\n.. Entity ID: " + entity.EntityId);
write("\n.. Entity Sequence: " + i);
write("\n.. Entity Class: " + entity.GetType());
write("\n.. Entity Type: " + entity.EntityType);
write("\n.. Subentities: " + entity.SubEntityCount);
}
}
//EntityId + Constraint.
private void GetAlignmentEntitiesInfo(String alignmentName)
{
ObjectId alignOid = doc.GetSitelessAlignmentId(alignmentName);
Alignment align = ts.GetObject(alignOid, OpenMode.ForRead) as Alignment;
m_editor.WriteMessage("\n---------User Story 4 :Alignment Entities properties- begin----------------\n");
AlignmentEntityCollection alignColl = align.Entities;
int count = alignColl.Count;
int alignID = alignColl.FirstEntity;
while (true)
{
AlignmentEntity alignEntity = alignColl.EntityAtId(alignID);
Debug.Assert(alignID == alignEntity.EntityId);
//m_editor.WriteMessage("Alignment EntityId : {0} Constraint : {1}\n", alignEntity.EntityId, alignEntity.Constraint);
if (alignID == alignColl.LastEntity)
{
break;
}
alignID = alignEntity.EntityAfter;
}
}
makeBaseline()
{
Layer.manageLayers("GRADING LIMIT");
Layer.manageLayers("SECTIONS");
SelectionSet objSSet = EW_Utility1.buildSSetGradingLim();
Entity ent = objSSet.GetObjectIds()[0].getEnt();
ObjectId idLim = ent.ObjectId;
double dblStationBase = 0;
bool boolUseBase;
Alignment objAlignBASE = null;
Alignment objAlign = Align.getAlignment("BASE");
if (objAlign != null)
{
DialogResult varResponse = MessageBox.Show("Use existing BASE alignment for sections?", "", MessageBoxButtons.YesNo);
if (varResponse == DialogResult.Yes)
{
objAlignBASE = objAlign;
dblStationBase = objAlignBASE.StartingStation;
objAlign = null;
boolUseBase = true;
}
else
{
boolUseBase = false;
objAlign.Name = "BASE_old";
}
}
else
{
boolUseBase = false;
}
List <Point3d> varPntInts = new List <Point3d>();
ObjectId idLWPline = ObjectId.Null, idLine = ObjectId.Null;
double dblAng = 0;
bool exists;
Point3d pnt3dCEN = Pub.pnt3dO, pnt3dTAR = Pub.pnt3dO, dPntBeg = Pub.pnt3dO, dPntEnd = Pub.pnt3dO;
if (!boolUseBase)
{
ObjectId idDictGRADEDOCK = Dict.getNamedDictionary("GRADEDOCK", out exists);
if (!exists)
{
Application.ShowAlertDialog("GRADEDOCK Dictionary missing. Create alignment BASE and try again.");
return;
}
else
{
ResultBuffer rb = Dict.getXRec(idDictGRADEDOCK, "CENTROID");
TypedValue[] tvs = rb.AsArray();
pnt3dCEN = new Point3d(double.Parse(tvs[0].Value.ToString()),
double.Parse(tvs[1].Value.ToString()),
double.Parse(tvs[2].Value.ToString()));
rb = Dict.getXRec(idDictGRADEDOCK, "TARGET");
tvs = rb.AsArray();
pnt3dTAR = new Point3d(double.Parse(tvs[0].Value.ToString()),
double.Parse(tvs[1].Value.ToString()),
double.Parse(tvs[2].Value.ToString()));
}
idLine = Draw.addLine(pnt3dCEN, pnt3dTAR);
varPntInts = idLine.intersectWith(idLim, extend.source);
idLine.delete();
dPntBeg = varPntInts[0];
dPntEnd = varPntInts[1];
dblAng = dPntBeg.getDirection(dPntEnd);
if (dblAng > pi / 2 & dblAng <= 3 * pi / 2)
{
varPntInts.Reverse();
dPntBeg = varPntInts[0];
dPntEnd = varPntInts[1];
dblAng = Measure.getAzRadians(dPntBeg, dPntEnd);
}
idLWPline = Draw.addPoly(varPntInts);
dblStationBase = 0;
}
Point3d pnt3dB = dPntBeg.traverse(dblAng, 10);
Point3d pnt3dE = dPntEnd.traverse(dblAng, 10);
Point3d pnt3dM = pnt3dB.getMidPoint3d(pnt3dE);
if ((objAlignBASE == null))
{
objAlignBASE = Align.addAlignmentFromPoly("BASE", "SECTIONS", idLWPline, "Standard", "Standard", true, true);
}
AlignmentEntityCollection ents = objAlignBASE.Entities;
AlignmentEntity objAlignEnt = ents[0];
if (objAlignEnt.EntityType == AlignmentEntityType.Line)
{
AlignmentLine objAlignEntTan = (AlignmentLine)objAlignEnt;
Point2d pnt2dBeg = objAlignEntTan.StartPoint;
Point2d pnt2dEnd = objAlignEntTan.EndPoint;
dblAng = pnt2dBeg.getDirection(pnt2dEnd);
}
int j = -1;
double easting = 0, northing = 0;
double dblOffR = 0, dblOffL = 0;
while (dblStationBase < objAlignBASE.Length)
{
j = j + 1;
dblStationBase = dblStationBase + j * 50;
objAlignBASE.PointLocation(dblStationBase, 0.0, ref easting, ref northing);
Point3d pnt3dX = new Point3d(easting, northing, 0);
Point3d varPntPolar = pnt3dX.traverse(dblAng + pi / 2, 100.0);
idLine = Draw.addLine(pnt3dX, varPntPolar);
varPntInts = idLine.intersectWith(idLim, extend.source);
idLine.delete();
StaOff sOff = new StaOff();
sOff.Sta = dblStationBase;
double dblStation = 0, dblOffset = 0;
for (int k = 0; k < varPntInts.Count; k++)
{
objAlignBASE.StationOffset(varPntInts[k].X, varPntInts[k].Y, ref dblStation, ref dblOffset);
if (dblOffset >= 0)
{
sOff.R = dblOffset;
}
else
{
sOff.L = System.Math.Abs(dblOffset);
}
if (sOff.R > dblOffR)
{
dblOffR = sOff.R;
}
if (sOff.L > dblOffL)
{
dblOffL = sOff.L;
}
if (k == 3)
{
break;
}
}
}
double dblRem = dblOffL % 10;
if (dblRem < 5)
{
dblOffL = System.Math.Round(dblOffL / 10, 0) * 10 + 10;
}
else
{
dblOffL = System.Math.Round(dblOffL / 10, 0) * 10;
}
dblRem = dblOffR % 10;
if (dblRem < 5)
{
dblOffR = System.Math.Round(dblOffR / 10, 0) * 10 + 10;
}
else
{
dblOffR = System.Math.Round(dblOffR / 10, 0) * 10;
}
EW_CmdSections.cmdSections(objAlignBASE.ObjectId, dblOffR, dblOffL);
}
/// <summary>
///
/// </summary>
/// <param name="ent"></param>
private void writeAlignData(AlignmentEntity ent)
{
BaseObjs.write(string.Format("\n.. Entity Class: {0}", ent.GetType()));
BaseObjs.write(string.Format("\n.. Entity Type: {0}", ent.EntityType));
BaseObjs.write(string.Format("\n.. Subentities: {0}", ent.SubEntityCount));
}
getCardinals_Horizontal(ObjectId idAlign, ref List <POI> varpoi)
{
Alignment objAlign = (Alignment)idAlign.getEnt();
//BEGIN HORIZONTAL CARDINALS
AlignmentEntityCollection objAlignEnts = objAlign.Entities;
AlignmentEntity objAlignEnt = objAlignEnts[0];
//GET BEG AND END OF FIRST SEGMENT - THEN GET END OF FOLLOWING SEGMENTS
switch (objAlignEnt.EntityType)
{
case AlignmentEntityType.Arc:
AlignmentArc objAlignEntArc = (AlignmentArc)objAlignEnt;
POI poi = new POI();
poi.Station = Math.roundDown3((objAlignEntArc.StartStation));
poi.Desc0 = "HC";
poi.ClassObj = fStake.ClassObj;
varpoi.Add(poi);
poi = new POI();
poi.Station = Math.roundDown3((objAlignEntArc.EndStation));
poi.Desc0 = "HC";
poi.ClassObj = fStake.ClassObj;
varpoi.Add(poi);
break;
case AlignmentEntityType.Line:
AlignmentLine objAlignEntTan = (AlignmentLine)objAlignEnt;
poi = new POI();
poi.Station = Math.roundDown3((objAlignEntTan.StartStation));
poi.Desc0 = "HC";
poi.ClassObj = fStake.ClassObj;
varpoi.Add(poi);
poi = new POI();
poi.Station = Math.roundDown3((objAlignEntTan.EndStation));
poi.Desc0 = "HC";
poi.ClassObj = fStake.ClassObj;
varpoi.Add(poi);
break;
}
POI vpoi = new POI();
if (objAlignEnts.Count > 1)
{
for (int i = 1; i <= objAlignEnts.Count - 1; i++)
{
objAlignEnt = objAlignEnts[i];
vpoi = new POI();
switch (objAlignEnt.EntityType)
{
case AlignmentEntityType.Arc:
AlignmentArc objAlignEntArc = (AlignmentArc)objAlignEnt;
vpoi.Station = Math.roundDown3((objAlignEntArc.EndStation));
vpoi.Desc0 = "HC";
vpoi.ClassObj = fStake.ClassObj;
break;
case AlignmentEntityType.Line:
AlignmentLine objAlignEntTan = (AlignmentLine)objAlignEnt;
vpoi.Station = Math.roundDown3((objAlignEntTan.EndStation));
vpoi.Desc0 = "HC";
vpoi.ClassObj = fStake.ClassObj;
break;
}
varpoi.Add(vpoi);
}
}
//END HORIZONTAL CARDINALS
}
listAlignEnts(Alignment objAlign)
{
AlignmentEntity objAlignEnt = default(AlignmentEntity);
AlignmentLine objAlignEntTan = default(AlignmentLine);
AlignmentArc objAlignEntArc = default(AlignmentArc);
List <AlgnEntData> varAlignData = null;
List <AlgnEntData> varAlignDataX = null;
int lngBefore = 0;
AlignmentEntityCollection ents = objAlign.Entities;
for (int i = 0; i < ents.Count; i++)
{
objAlignEnt = ents[i];
AlgnEntData alignData = new AlgnEntData();
if (objAlignEnt.EntityType == AlignmentEntityType.Arc)
{
objAlignEntArc = (AlignmentArc)objAlignEnt;
alignData.ID = objAlignEntArc.EntityId;
alignData.Type = "Arc";
alignData.StaBeg = System.Math.Round(objAlignEntArc.StartStation, 2);
alignData.StaEnd = System.Math.Round(objAlignEntArc.EndStation, 2);
alignData.Length = System.Math.Round(objAlignEntArc.Length, 2);
alignData.Radius = System.Math.Round(objAlignEntArc.Radius, 2);
alignData.EntBefore = objAlignEntArc.EntityBefore;
varAlignData.Add(alignData);
}
else if (objAlignEnt.EntityType == AlignmentEntityType.Line)
{
objAlignEntTan = (AlignmentLine)objAlignEnt;
alignData.ID = objAlignEntTan.EntityId;
alignData.Type = "Tangent";
alignData.StaBeg = System.Math.Round(objAlignEntTan.StartStation, 2);
alignData.StaEnd = System.Math.Round(objAlignEntTan.EndStation, 2);
alignData.Length = System.Math.Round(objAlignEntTan.Length, 2);
alignData.Radius = 0.0;
alignData.EntBefore = objAlignEntTan.EntityBefore;
varAlignData.Add(alignData);
}
}
int n = -1;
int k = 0;
do
{
for (int i = 0; i < ents.Count; i++)
{
if (varAlignData[i].EntBefore == lngBefore)
{
n += 1; //n is index for new list
varAlignDataX[n] = varAlignData[i];
k = i;
break;
}
}
lngBefore = varAlignData[k].ID;
}while (n < ents.Count);
return(varAlignDataX);
}
/// <summary>
/// Assigns the wrapped entity.
/// </summary>
/// <param name="entity">Entity to wrap.</param>
internal void AssignEntity(AlignmentEntity entity)
{
m_TheEntity = entity;
}
getNestedPoints(ObjectId idAlign, ref List <POI> varpoi, BlockTableRecord objXRefDbModelSpace, string strSource)
{
Alignment objAlign = (Alignment)idAlign.getEnt();
string strNameStakeObject = fStake.NameStakeObject;
double dblToleranceLength = 0.15;
double dblToleranceAngle = PI;
Point2d varPntRef = objAlign.ReferencePoint;
string strFilter = "";
if (strSource.Contains("GCAL")
)
{
strFilter = "*CPNT*";
}
else
{
strFilter = "*";
}
List <string> strPntNums = new List <string>();
double dblStation = 0, dblOffset = 0;
ResultBuffer rb = null;
TypedValue[] tvs = null;
List <POI> varPOI_PNTs = new List <POI>();
foreach (ObjectId id in objXRefDbModelSpace)
{
bool boolAdd = false;
Entity objXRefObj = id.getEnt();
if (objXRefObj is CogoPoint)
{
CogoPoint objPnt = (CogoPoint)objXRefObj;
Debug.Print(objPnt.PointNumber.ToString());
if (objPnt.Layer.Contains(strFilter))
{
strPntNums.Add(objPnt.PointNumber.ToString());
if (strSource == "GCAL")
{
rb = id.getXData("STAKE");
tvs = rb.AsArray();
}
objAlign.StationOffset(objPnt.Easting, objPnt.Northing, ref dblStation, ref dblOffset);
Debug.Print(objPnt.Easting + "," + objPnt.Northing);
Point2d pnt2d = new Point2d(objPnt.Location.X, objPnt.Location.Y);
if (System.Math.Abs(dblOffset) < dblToleranceLength)
{
if (dblStation >= objAlign.StartingStation && dblStation <= objAlign.EndingStation)
{
boolAdd = true;
}
}
else if (pnt2d.isEqual(varPntRef, dblToleranceLength))
{
Point3d pnt3d = new Point3d(objPnt.Easting, objPnt.Northing, 0);
double dblAngle1 = Math.roundDown3(pnt2d.getDirection(varPntRef));
AlignmentEntity objAlignEnt = objAlign.Entities.EntityAtId(objAlign.Entities.FirstEntity);
switch (objAlignEnt.EntityType)
{
case AlignmentEntityType.Arc:
AlignmentArc objAlignEntArc = (AlignmentArc)objAlignEnt;
double dblangle2 = 0;
if (objAlignEntArc.Clockwise)
{
dblangle2 = objAlignEntArc.StartDirection - PI / 2 + objAlignEntArc.Delta / 2;
}
else
{
dblangle2 = objAlignEntArc.StartDirection + PI / 2 - objAlignEntArc.Delta / 2;
}
if (System.Math.Abs(dblAngle1 - dblangle2) < dblToleranceAngle)
{
boolAdd = true;
dblStation = objAlign.StartingStation;
}
else if (System.Math.Abs(Math.roundDown3(dblAngle1 - 2 * PI) - dblangle2) < dblToleranceAngle)
{
boolAdd = true;
dblStation = objAlign.StartingStation;
}
break;
case AlignmentEntityType.Line:
AlignmentLine objAlignEntTan = (AlignmentLine)objAlignEnt;
dblangle2 = Math.roundDown3((objAlignEntTan.Direction));
if (System.Math.Abs(dblAngle1 - dblangle2) < dblToleranceAngle)
{
boolAdd = true;
dblStation = objAlign.StartingStation;
}
break;
}
}
else
{
boolAdd = false;
}
}
if (boolAdd == true)
{
POI varPOI_PNT = new POI();
varPOI_PNT.Station = Math.roundDown3(dblStation);
varPOI_PNT.PntNum = objPnt.PointNumber.ToString();
varPOI_PNT.Elevation = System.Math.Round(objPnt.Elevation, 3);
if (strSource != "WALLDESIGN")
{
varPOI_PNT.ClassObj = fStake.ClassObj;
}
varPOI_PNT.OFFSET = System.Math.Round(dblOffset, 2);
varPOI_PNT.PntSource = strSource;
if (strSource == "GCAL")
{
try
{
if (isTG(objXRefDbModelSpace, tvs[1].Value.ToString().stringToHandle()))
{
varPOI_PNT.Desc0 = "TG";
}
}
catch (System.Exception)
{
varPOI_PNT.Desc0 = "PNT";
}
}
else if (strSource == "WALLDESIGN")
{
objAlign.StationOffset(objPnt.Easting, objPnt.Northing, ref dblStation, ref dblOffset);
varPOI_PNT.OFFSET = System.Math.Round(dblOffset, 2);
varPOI_PNT.Desc0 = string.Format("{0} {0} {2}", objPnt.RawDescription, varPOI_PNT.OFFSET, varPOI_PNT.Elevation);
varPOI_PNT.PntSource = "TOPO";
}
else
{
varPOI_PNT.Desc0 = "PNT";
}
varPOI_PNTs.Add(varPOI_PNT);
}
}
}
if (varPOI_PNTs.Count > 0)
{
var sortSta = from p in varPOI_PNTs
orderby p.Station ascending
select p;
List <POI> poiTmp = new List <POI>();
foreach (var p in sortSta)
{
poiTmp.Add(p);
}
Stake_Util.removeDuplicatePoints(ref poiTmp);
varPOI_PNTs = poiTmp;
if (strSource != "WALLDESIGN")
{
fStake.POI_PNTs = varPOI_PNTs;
}
if (varPOI_PNTs[0].Desc0 != "NOTHING")
{
for (int i = 0; i < varPOI_PNTs.Count; i++)
{
varpoi.Add(varPOI_PNTs[i]);
}
}
poiTmp = varpoi;
sortSta = from p in poiTmp
orderby p.Station ascending
select p;
varpoi = new List <POI>();
foreach (var p in sortSta)
{
varpoi.Add(p);
}
return(true);
}
return(false);
}
copyAlignFromXref(ObjectId idAlign, string strSource)
{
Alignment objAlign = (Alignment)idAlign.getEnt();
AlignmentEntityCollection objAlignEnts = default(AlignmentEntityCollection);
AlignmentEntity objAlignEnt = default(AlignmentEntity);
AlignmentArc objAlignEntArc = default(AlignmentArc);
AlignmentLine objAlignEntTan = default(AlignmentLine);
Point2d pnt2dBeg = objAlign.ReferencePoint;
double dblStationStart = objAlign.ReferencePointStation;
string strAlignName = objAlign.Name;
StationEquationCollection objStationEQs = objAlign.StationEquations;
List <AlgnEntData> varAlignEntData = listAlignEnts(objAlign);
objAlignEnts = objAlign.Entities;
List <Vertex2d> pnts2dPoly = new List <Vertex2d>();
double bulge = 0;
for (int i = 0; i < varAlignEntData.Count; i++)
{
objAlignEnt = objAlignEnts.EntityAtId(varAlignEntData[i].ID);
if (objAlignEnt.EntityType == AlignmentEntityType.Arc)
{
objAlignEntArc = (AlignmentArc)objAlignEnt;
if (i == objAlignEnts.Count - 1)
{
bulge = System.Math.Tan(objAlignEntArc.Delta / 4);
if (objAlignEntArc.Clockwise)
{
bulge = bulge * -1.0;
}
pnts2dPoly.Add(new Vertex2d(new Point3d(objAlignEntArc.StartPoint.X, objAlignEntArc.StartPoint.Y, 0), bulge, 0, 0, 0));
pnts2dPoly.Add(new Vertex2d(new Point3d(objAlignEntArc.EndPoint.X, objAlignEntArc.EndPoint.Y, 0), 0, 0, 0, 0));
}
else
{
bulge = System.Math.Tan(objAlignEntArc.Delta / 4);
if (objAlignEntArc.Clockwise)
{
bulge = bulge * -1;
}
pnts2dPoly.Add(new Vertex2d(new Point3d(objAlignEntArc.StartPoint.X, objAlignEntArc.StartPoint.Y, 0), bulge, 0, 0, 0));
}
}
else if (objAlignEnt.EntityType == AlignmentEntityType.Line)
{
objAlignEntTan = (AlignmentLine)objAlignEnt;
if (i == objAlignEnts.Count - 1)
{
pnts2dPoly.Add(new Vertex2d(new Point3d(objAlignEntTan.StartPoint.X, objAlignEntTan.StartPoint.Y, 0), 0, 0, 0, 0));
pnts2dPoly.Add(new Vertex2d(new Point3d(objAlignEntTan.EndPoint.X, objAlignEntTan.EndPoint.Y, 0), 0, 0, 0, 0));
}
else
{
pnts2dPoly.Add(new Vertex2d(new Point3d(objAlignEntTan.StartPoint.X, objAlignEntTan.StartPoint.Y, 0), 0, 0, 0, 0));
}
}
}
ObjectId idPoly = Draw.addPoly(pnts2dPoly);
string strLayer = "";
if (strSource == "WALLDESIGN")
{
strLayer = "WALL-PROFILE";
}
else
{
strLayer = strSource;
}
Layer.manageLayers(strLayer);
Alignment objAlignNew = null;
try
{
objAlignNew = Align.addAlignmentFromPoly(strAlignName, strLayer, idPoly, "Standard", "Standard", true);
}
catch (System.Exception ex)
{
System.Diagnostics.Debug.Print(ex.ToString());
return(null);
}
objAlignNew.ReferencePointStation = dblStationStart;
double dblStaBack = 0;
double dblStaAhead = 0;
StationEquationType objStaEqType = default(StationEquationType);
for (int i = 0; i <= objStationEQs.Count - 1; i++)
{
dblStaBack = objStationEQs[i].RawStationBack;
dblStaAhead = objStationEQs[i].StationAhead;
objStaEqType = objStationEQs[i].EquationType;
objAlignNew.StationEquations.Add(dblStaBack, dblStaAhead, objStaEqType);
}
return(objAlignNew);
}
getBC_EC(ObjectId idAlign, ref List <POI> varpoi)
{
bool boolExists = false;
Profile objProfile = null;
Alignment objAlign = (Alignment)idAlign.getEnt();
try
{
objProfile = Prof.getProfile(idAlign, "FLOWLINE");
}
catch (System.Exception)
{
objProfile = Prof.getProfile(idAlign, "STAKE");
}
string strClass = fStake.ClassObj;
AlignmentEntityCollection objAlignEnts = objAlign.Entities;
bool isRightHand = false;
if (objAlignEnts.Count > 1)
{
for (int i = 0; i < objAlignEnts.Count; i++)
{
AlignmentEntity objAlignEnt = objAlignEnts[i];
if (objAlignEnt.EntityType == AlignmentEntityType.Arc)
{
boolExists = false;
AlignmentArc objAlignEntArc = (AlignmentArc)objAlignEnt;
isRightHand = !(objAlignEntArc.Clockwise);
double dblStationBC = System.Math.Round(objAlignEntArc.StartStation, 3);
int x = 0;
for (int j = 0; j < varpoi.Count; j++)
{
if (System.Math.Abs(varpoi[j].Station - dblStationBC) < 0.05)
{
boolExists = true;
x = j;
break;
}
}
double dblBulge = 0;
double dblAngDirCen = objAlignEntArc.StartPoint.getDirection(objAlignEntArc.CenterPoint);//direction to center of arc
double dblAngDelta = objAlignEntArc.Delta;
double dblRadius = System.Math.Round(objAlignEntArc.Radius, 2);
Point2d dblPntCen = objAlignEntArc.CenterPoint;
if (boolExists)
{
dblBulge = System.Math.Tan(objAlignEntArc.Delta / 4);
if (objAlignEntArc.Clockwise)
{
dblBulge = dblBulge * -1.0;
}
POI vpoi = varpoi[x];
vpoi.Station = Math.roundDown3(dblStationBC);
if (vpoi.Desc0 == "EC")
{
vpoi.Desc0 = "PCC";
}
else
{
vpoi.Desc0 = "BC";
}
vpoi.AngDir = dblAngDirCen;
vpoi.isRightHand = isRightHand;
vpoi.Bulge = dblBulge;
vpoi.Radius = dblRadius;
vpoi.CenterPnt = new Point3d(dblPntCen.X, dblPntCen.Y, 0);
varpoi[x] = vpoi;
}
else
{
string strDesc = "BC";
double dblElev = 0;
try
{
dblElev = objProfile.ElevationAt(dblStationBC);
}
catch (System.Exception)
{
try
{
dblElev = objProfile.ElevationAt(dblStationBC + 0.05);
}
catch (System.Exception)
{
idAlign.delete();
Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog(string.Format("Design Point not found at beginning of Arc @ {0:###+00.00} - revise and retry - exiting", dblStationBC));
return(false);
}
}
if (dblElev != 0)
{
dblBulge = System.Math.Tan(objAlignEntArc.Delta / 4);
if (objAlignEntArc.Clockwise)
{
dblBulge = dblBulge * -1.0;
}
dblRadius = System.Math.Round(objAlignEntArc.Radius, 2);
POI vpoi = new POI();
vpoi.Station = dblStationBC;
vpoi.Desc0 = strDesc;
vpoi.ClassObj = strClass;
vpoi.AngDelta = dblAngDelta;
vpoi.AngDir = dblAngDirCen;
vpoi.isRightHand = isRightHand;
vpoi.Elevation = dblElev;
vpoi.Bulge = dblBulge;
vpoi.Radius = dblRadius;
vpoi.CenterPnt = new Point3d(dblPntCen.X, dblPntCen.Y, 0);
varpoi.Add(vpoi);
varpoi = varpoi.sortPOIbyStation();
}
}
boolExists = false;
double dblStationEC = System.Math.Round(objAlignEntArc.EndStation, 3);
x = 0;
for (int j = 0; j < varpoi.Count; j++)
{
if (System.Math.Abs(varpoi[j].Station - dblStationEC) < 0.05)
{
boolExists = true;
x = j;
break;
}
}
dblAngDirCen = objAlignEntArc.EndPoint.getDirection(objAlignEntArc.CenterPoint);
if (boolExists)
{
POI vpoi = varpoi[x];
vpoi.Station = Math.roundDown3(dblStationEC);
vpoi.Desc0 = "EC";
vpoi.AngDir = dblAngDirCen;
vpoi.isRightHand = isRightHand;
vpoi.Bulge = dblBulge;
vpoi.Radius = dblRadius;
varpoi[x] = vpoi;
}
else
{
string strDesc = "EC";
double dblElev = 0;
try
{
dblElev = objProfile.ElevationAt(dblStationEC);
}
catch (System.Exception)
{
dblElev = objProfile.ElevationAt(dblStationBC - 0.05);
}
POI vpoi = new POI();
vpoi.Station = dblStationEC;
vpoi.Desc0 = strDesc;
vpoi.ClassObj = strClass;
vpoi.AngDelta = dblAngDelta;
vpoi.AngDir = dblAngDirCen;
vpoi.isRightHand = isRightHand;
vpoi.Elevation = dblElev;
vpoi.Bulge = dblBulge;
vpoi.Radius = dblRadius;
varpoi.Add(vpoi);
varpoi = varpoi.sortPOIbyStation();
}
}
}
}
return(true);
}
getNestedPoints(ObjectId idAlign, ref List <POI> varPOI, BlockTableRecord btrMS, string strSource)
{
bool boolAdd = false;
double dblToleranceAngle = PI, dblToleranceLength = 0, dblStation = 0, dblOffset = 0;
Point2d pnt2dRef = idAlign.getAlignRefPoint();
string strFilter = "*";
if (strSource.Contains("GCAL"))
{
strFilter = "*CPNT*";
}
ObjectIdCollection ids = Cogo.getNestedPoints(btrMS);
List <POI> varPOI_PNTs = new List <POI>();
Alignment objAlign = (Alignment)idAlign.getEnt();
using (var tr = BaseObjs.startTransactionDb()) {
foreach (ObjectId id in ids)
{
CogoPoint cogoPnt = (CogoPoint)tr.GetObject(id, OpenMode.ForRead);
if (cogoPnt.Layer.Contains(strFilter))
{
try {
idAlign.getAlignStaOffset(cogoPnt.Location, ref dblStation, ref dblOffset);
}
catch (Autodesk.Civil.PointNotOnEntityException) {
dblStation = 0.0;
}
if (dblStation != 0)
{
if (dblOffset < dblToleranceLength)
{
boolAdd = true;
}
}
else
{
Debug.Print(string.Format("{0},{1}", cogoPnt.Easting, cogoPnt.Northing));
Point2d pnt2d = new Point2d(cogoPnt.Easting, cogoPnt.Northing);
//distance from reference point < tolerance
if (pnt2d.getDistance(pnt2dRef) < dblToleranceLength)
{
double dblAngle1 = Base_Tools45.Math.roundDown3(pnt2d.getDirection(pnt2dRef));
AlignmentEntity objAlignEnt = objAlign.Entities.EntityAtId(objAlign.Entities.FirstEntity);
switch (objAlignEnt.EntityType)
{
case AlignmentEntityType.Arc:
AlignmentArc objAlignEntArc = (AlignmentArc)objAlignEnt;
double dblangle2 = Base_Tools45.Math.roundDown3(objAlignEntArc.StartDirection);
if (System.Math.Abs(dblAngle1 - dblangle2) < dblToleranceAngle)
{
boolAdd = true;
dblStation = objAlign.StartingStation;
}
else if (System.Math.Abs(Base_Tools45.Math.roundDown3(dblAngle1 - 2 * PI) - dblangle2) < dblToleranceAngle)
{
boolAdd = true;
dblStation = objAlign.StartingStation;
}
break;
case AlignmentEntityType.Line:
AlignmentLine objAlignEntTan = (AlignmentLine)objAlignEnt;
dblangle2 = Base_Tools45.Math.roundDown3(objAlignEntTan.Direction);
if (System.Math.Abs(dblAngle1 - dblangle2) < dblToleranceAngle)
{
boolAdd = true;
dblStation = objAlign.StartingStation;
}
break;
}
}
else
{
boolAdd = false;
}
//4
}
if (boolAdd == true)
{
POI vPOI_PNT = new POI();
vPOI_PNT.Station = Base_Tools45.Math.roundDown3(dblStation);
vPOI_PNT.PntNum = cogoPnt.PointNumber.ToString();
vPOI_PNT.Elevation = System.Math.Round(cogoPnt.Elevation, 3);
vPOI_PNT.OFFSET = System.Math.Round(dblOffset, 2);
vPOI_PNT.PntSource = strSource;
try {
objAlign.StationOffset(cogoPnt.Easting, cogoPnt.Northing, ref dblStation, ref dblOffset);
}
catch (Autodesk.Civil.PointNotOnEntityException) {
dblStation = 0.0;
}
vPOI_PNT.OFFSET = System.Math.Round(dblOffset, 2);
vPOI_PNT.Desc0 = string.Format("{0} {1} {2}", cogoPnt.RawDescription, vPOI_PNT.OFFSET, vPOI_PNT.Elevation);
vPOI_PNT.PntSource = "TOPO";
varPOI_PNTs.Add(vPOI_PNT);
}
}
}
tr.Commit();
}
if (varPOI_PNTs.Count > 0)
{
dynamic sta = from data in varPOI_PNTs
orderby data.Station
select data;
List <POI> t = new List <POI>();
foreach (var p in sta)
{
t.Add(p);
}
varPOI_PNTs = t;
Misc.removeDuplicatePoints(ref varPOI_PNTs);
sta = from data in varPOI_PNTs
orderby data.Station
select data;
t = new List <POI>();
foreach (var p in sta)
{
t.Add(p);
}
varPOI = t;
}
else
{
return(false);
}
return(true);
}
private void cmdUpdate_Click(object sender, EventArgs e)
{
Control cntrl;
ControlCollection cntrls = (ControlCollection)this.Controls;
List <AlgnEntData> algnData = new List <AlgnEntData>();
int k = cntrls.Count;
k = (k - 9) / 1 - 1;
Object[,] varData = new object[k, 6];
for (int i = 0; i < cntrls.Count; i++)
{
cntrl = cntrls[i];
if (cntrl.Name.Contains("lbl"))
{
int id = int.Parse(cntrl.Name.Substring(4, 1));
int idx = id + 2;
varData[id, idx] = cntrl.Text;
}
}
AlgnEntData aData;
for (int i = 0; i < k; i++)
{
aData = new AlgnEntData();
aData.ID = int.Parse(varData[i, 1].ToString());
aData.Type = varData[i, 2].ToString();
aData.StaBeg = double.Parse(varData[i, 3].ToString());
aData.StaEnd = double.Parse(varData[i, 4].ToString());
aData.Length = double.Parse(varData[i, 5].ToString());
aData.Radius = double.Parse(varData[i, 6].ToString());
algnData.Add(aData);
}
Alignment align = (Alignment)idAlign.getEnt();
AlignmentEntityCollection ents = align.Entities;
bool changed = false;
for (int i = 0; i < ents.Count; i++)
{
AlignmentEntity ent = ents[i];
if (ent.EntityType == AlignmentEntityType.Arc)
{
if (algnData[1].Radius == 0)
{
ents.Remove(ent);
changed = true;
}
}
else
{
AlignmentArc arc = (AlignmentArc)ent;
if (!arc.Radius.Equals(algnData[i].Radius))
{
arc.Radius = algnData[i].Radius;
changed = true;
}
}
if (changed)
{
this.Close();
MNP_Align.editAlign(align.ObjectId);
}
}
}
set5x5(ObjectId idAlign, double dblElev, double dblStation, double dblOffset, int intSide, string strName, string strDesc)
{
double dblAngBack = 0;
double dblAngAhead = 0;
double dblEasting0 = 0;
double dblNorthing0 = 0;
Alignment objAlign = (Alignment)idAlign.getEnt();
AlignmentEntityCollection alignEnts = objAlign.Entities;
//Debug.Print objAlign.EndingStation
AlignmentEntity alignEnt0 = (AlignmentEntity)alignEnts.EntityAtStation(dblStation);
AlignmentLine alignLine0 = null;
AlignmentSubEntityLine subEntLine0 = null;
if (alignEnt0.EntityType == AlignmentEntityType.Line)
{
alignLine0 = (AlignmentLine)alignEnts.EntityAtStation(dblStation);
subEntLine0 = (AlignmentSubEntityLine)alignLine0[0];
}
else
{
return;
}
AlignmentLine alignLineA = null;
AlignmentLine alignLineB = null;
AlignmentEntity alignEntX = null;
Point2d pnt2dBeg = Point2d.Origin;
Point2d pnt2dEnd = Point2d.Origin;
//Point at Tangent Start Point
if (Math.roundDown3(dblStation) == Math.roundDown3(alignLine0.StartStation))
{
alignLineA = alignLine0;
pnt2dBeg = alignLineA.StartPoint;
pnt2dEnd = alignLineA.EndPoint;
dblAngAhead = pnt2dBeg.getDirection(pnt2dEnd);
//First Tangent
if (alignEnt0.EntityBefore != 0)
{
alignEntX = alignEnts[alignEnt0.EntityBefore - 1];
if (alignEntX.EntityType == AlignmentEntityType.Line)
{
alignLineB = (AlignmentLine)alignEntX;
pnt2dBeg = alignLineB.StartPoint;
pnt2dEnd = alignLineB.EndPoint;
dblAngBack = pnt2dBeg.getDirection(pnt2dEnd);
}
}
else
{
dblAngBack = dblAngAhead;
// Debug.Print dblAngBack
}
//Point at Tangent End Point
}
else if (Math.roundDown3(dblStation) == Math.roundDown3(alignLine0.EndStation))
{
alignLineB = alignLine0;
pnt2dBeg = alignLineB.StartPoint;
pnt2dEnd = alignLineB.EndPoint;
dblAngBack = pnt2dBeg.getDirection(pnt2dEnd);
//Last Tangent
if (alignEnt0.EntityAfter != 0)
{
alignEntX = alignEnts[alignLine0.EntityAfter - 1];
if (alignEntX.EntityType == AlignmentEntityType.Line)
{
alignLineA = (AlignmentLine)alignEntX;
pnt2dBeg = alignLineA.StartPoint;
pnt2dEnd = alignLineA.EndPoint;
dblAngAhead = pnt2dBeg.getDirection(pnt2dEnd);
}
}
else
{
dblAngAhead = dblAngBack;
}
}
else
{
pnt2dBeg = alignLine0.StartPoint;
pnt2dEnd = alignLine0.EndPoint;
dblAngAhead = pnt2dBeg.getDirection(pnt2dEnd);
}
idAlign.getAlignPointLoc(dblStation, 0.0, ref dblEasting0, ref dblNorthing0);
//get point of intersection
Point3d pnt3d = new Point3d(dblEasting0, dblNorthing0, 0.0);
Point3d pnt3dX = pnt3d.traverse(dblAngAhead + (3 * PI / 4 * intSide * -1), dblOffset / System.Math.Sin(PI / 4));
pnt3dX = pnt3dX.addElevation(dblElev);
string strOffset = string.Format("{0} x {1}", dblOffset.ToString(), dblOffset.ToString());
Debug.Print(dblStation + " set5x5");
setOffsetPoint(pnt3dX, strOffset, strName, strDesc, idAlign, dblStation);
pnt3dX = pnt3dX.traverse(dblAngAhead + (PI / 4 * intSide * -1), dblOffset / System.Math.Sin(PI / 4));
pnt3dX = pnt3dX.addElevation(dblElev);
strOffset = string.Format("{0} x {1}", dblOffset.ToString(), dblOffset.ToString());
Debug.Print(dblStation + " set5x5");
setOffsetPoint(pnt3dX, strOffset, strName, strDesc, idAlign, dblStation);
}
getAnglePoints(ObjectId idAlign, ref List <POI> varpoi)
{
POI vPoi = new POI();
bool boolClosed = false;
string strClass = fStake.ClassObj;
Profile objProfile = null;
switch (strClass)
{
case "CURB":
objProfile = Prof.getProfile(idAlign, "FLOWLINE");
break;
case "FL":
objProfile = Prof.getProfile(idAlign, "STAKE");
break;
case "WTR":
objProfile = Prof.getProfile(idAlign, "CPNT");
break;
case "BLDG":
vPoi = new POI();
break;
}
Alignment objAlign = (Alignment)idAlign.getEnt();
AlignmentEntityCollection objAlignEnts = objAlign.Entities;
double dblElev = 0;
bool isRightHand = false;
AlignmentEntity objAlignEnt0 = null;
AlignmentEntity objAlignEntX = null;
AlignmentLine objAlignTan0 = null;
AlignmentLine objAlignTanX = null;
AlignmentArc objAlignArc0 = null;
AlignmentArc objAlignArcX = null;
if (objAlignEnts.Count > 1)
{
for (int i = 0; i < objAlignEnts.Count - 1; i++)
{
objAlignEnt0 = objAlignEnts[i + 0];
objAlignEntX = objAlignEnts[i + 1];
if (objAlignEnt0.EntityType == AlignmentEntityType.Line)
{
objAlignTan0 = (AlignmentLine)objAlignEnt0;
if (objAlignEntX.EntityType == AlignmentEntityType.Line)
{
objAlignTanX = (AlignmentLine)objAlignEntX;
double dblAng0 = objAlignTan0.StartPoint.getDirection(objAlignTan0.EndPoint);
double dblAngX = objAlignTanX.StartPoint.getDirection(objAlignTanX.EndPoint);
if (System.Math.Round(dblAng0, 3) != System.Math.Round(dblAngX, 3))
{
Point3d pnt3d1 = new Point3d(objAlignTan0.StartPoint.X, objAlignTan0.StartPoint.Y, 0);
Point3d pnt3d2 = new Point3d(objAlignTan0.EndPoint.X, objAlignTan0.EndPoint.Y, 0);
Point3d pnt3d3 = new Point3d(objAlignTanX.EndPoint.X, objAlignTanX.EndPoint.Y, 0);
double dblStation = System.Math.Round(objAlignTanX.StartStation, 3);
// Debug.Print i
double dblAngDelta = Geom.getAngle3Points(pnt3d1, pnt3d2, pnt3d3);
double dblAngDir = dblAngX;
Vector3d v3d1 = pnt3d2 - pnt3d1;
Vector3d v3d2 = pnt3d3 - pnt3d2;
Vector3d v3dC = v3d1.CrossProduct(v3d2);
if (v3dC.Z > 0)
{
isRightHand = true;
}
else
{
isRightHand = false;
}
switch (strClass)
{
case "CURB":
case "FL":
case "WTR":
try
{
dblElev = System.Math.Round(objProfile.ElevationAt(dblStation), 3);
}
catch (System.Exception)
{
}
break;
}
POI vpoi = new POI();
vpoi.Station = dblStation;
vpoi.Desc0 = "AP";
vpoi.ClassObj = strClass;
vpoi.AngDelta = dblAngDelta;
vpoi.AngDir = dblAngDir;
vpoi.isRightHand = isRightHand;
vpoi.Elevation = dblElev;
varpoi.Add(vpoi);
varpoi = varpoi.sortPOIbyStation();
}
}
}
}
}
objAlignEnt0 = objAlignEnts[objAlignEnts.FirstEntity - 1];
objAlignEntX = objAlignEnts[objAlignEnts.LastEntity - 1];
bool boolArc0 = false;
bool boolArcX = false;
bool boolTan0 = false;
bool boolTanX = false;
Point2d pnt2dBeg = Point2d.Origin, pnt2dEnd = Point2d.Origin;
if (objAlignEnt0.EntityType == AlignmentEntityType.Arc)
{
objAlignArc0 = (AlignmentArc)objAlignEnt0;
pnt2dBeg = objAlignArc0.StartPoint;
boolArc0 = true;
}
else
{
objAlignTan0 = (AlignmentLine)objAlignEnt0;
pnt2dBeg = objAlignTan0.StartPoint;
boolTan0 = true;
}
if (objAlignEntX.EntityType == AlignmentEntityType.Arc)
{
objAlignArcX = (AlignmentArc)objAlignEntX;
pnt2dEnd = objAlignArcX.StartPoint;
boolArcX = true;
}
else
{
objAlignTanX = (AlignmentLine)objAlignEntX;
pnt2dEnd = objAlignTanX.StartPoint;
boolTanX = true;
}
if (System.Math.Round(pnt2dEnd.X, 2) == System.Math.Round(pnt2dBeg.X, 2))
{
if (System.Math.Round(pnt2dEnd.Y, 2) == System.Math.Round(pnt2dBeg.Y, 2))
{
boolClosed = true;
varpoi[0].isClosed = true;
if (boolArc0 & boolArcX)
{
varpoi[0].Desc0 = "PCC";
}
else if (boolArc0 & boolTanX)
{
//do nothing
}
else if (boolTan0 & boolArcX)
{
varpoi[0].Desc0 = "EC";
}
else if (boolTan0 & boolTanX)
{
Point3d pnt3d1 = new Point3d(objAlignTanX.StartPoint.X, objAlignTanX.StartPoint.Y, 0);
Point3d pnt3d2 = new Point3d(objAlignTanX.EndPoint.X, objAlignTanX.EndPoint.Y, 0);
Point3d pnt3d3 = new Point3d(objAlignTan0.EndPoint.X, objAlignTan0.EndPoint.Y, 0);
double dblAngDelta = Geom.getAngle3Points(pnt3d1, pnt3d2, pnt3d3);
double dblAng0 = objAlignTan0.StartPoint.getDirection(objAlignTan0.EndPoint);
double dblAngDir = dblAng0;
Vector3d v3d1 = pnt3d2 - pnt3d1;
Vector3d v3d2 = pnt3d3 - pnt3d2;
Vector3d v3dC = v3d1.CrossProduct(v3d2);
if (v3dC.Z > 0)
{
isRightHand = true;
}
else
{
isRightHand = false;
}
if (strClass == "BLDG")
{
varpoi[0].Station = objAlignTan0.StartStation;
varpoi[0].Desc0 = "AP";
varpoi[0].DescX = "BEG AP";
varpoi[0].ClassObj = strClass;
varpoi[0].AngDelta = dblAngDelta;
varpoi[0].AngDir = dblAngDir;
}
else
{
varpoi[0].Desc0 = "AP";
varpoi[0].DescX = "BEG AP";
varpoi[0].AngDelta = dblAngDelta;
varpoi[0].AngDir = dblAngDir;
}
}
}
}
if (boolClosed)
{
int j = varpoi.Count - 1;
if (varpoi[j].Station != Math.roundDown3((objAlign.EndingStation)))
{
POI vpoi = new POI();
vpoi.Station = Math.roundDown3((objAlign.EndingStation));
vpoi.Elevation = varpoi[0].Elevation;
if (strClass == "BLDG")
{
vpoi.DescX = varpoi[0].DescX;
}
else
{
vpoi.DescX = "END AP";
}
vpoi.Desc0 = "AP";
vpoi.ClassObj = strClass;
vpoi.isClosed = true;
varpoi.Add(vpoi);
}
else
{
POI vpoi = varpoi[j];
vpoi.Elevation = varpoi[0].Elevation;
vpoi.Desc0 = "AP";
if (strClass == "BLDG")
{
vpoi.DescX = varpoi[0].DescX;
}
vpoi.DescX = "END AP";
vpoi.ClassObj = strClass;
vpoi.isClosed = true;
varpoi[j] = vpoi;
}
}
}
makePipeNetwork(ObjectId idAlign, string nameNetwork, string pipeType)
{
string pntDesc = fMNP.pntDesc;
Point3d pnt3dPick = Pub.pnt3dO;
if (idAlign == ObjectId.Null)
{
Autodesk.AutoCAD.DatabaseServices.Entity ent = Select.selectEntity(typeof(Alignment), "Select Alignment: ", "Selected object was not an alignment. Try again: ", out pnt3dPick);
idAlign = ent.ObjectId;
}
Network net = null;
ObjectIdCollection ids = CivilApplication.ActiveDocument.GetPipeNetworkIds();
ObjectId idNet = ObjectId.Null;
if (ids.Count == 0)
{
idNet = Network.Create(CivilApplication.ActiveDocument, ref nameNetwork);
}
else
{
for (int i = 0; i < ids.Count; i++)
{
net = (Network)ids[i].getEnt();
//if (net.Name == nameNetwork){
// string index = Align.getAlignIndex(nameNetwork);
// nameNetwork = string.Format("{0}-{1}", nameNetwork, index);
// break;
//}
}
idNet = Network.Create(CivilApplication.ActiveDocument, ref nameNetwork);
}
bool exists = false;
Alignment align = (Alignment)idAlign.getEnt();
AlignmentEntityCollection ents = align.Entities;
TinSurface tinSurfDE = Surf.getTinSurface("CPNT-ON", out exists);
List <AlgnEntData> algnData = MNP_Align.sortAlignEnts(align);
List <string> hPipe = new List <string>();
List <ObjectId> idsCgPnt = new List <ObjectId>();
ObjectId idPipe, idPipeSize, idStruct, idStructSize;
using (Transaction tr = BaseObjs.startTransactionDb())
{
net = (Network)tr.GetObject(idNet, OpenMode.ForWrite);
net.ReferenceAlignmentId = idAlign;
net.ReferenceSurfaceId = Surf.getTinSurface("CPNT-ON", out exists).ObjectId;
ObjectId idPartsList = CivilApplication.ActiveDocument.Styles.PartsListSet["Standard"];
PartsList partsList = (PartsList)tr.GetObject(idPartsList, OpenMode.ForRead);
idPipe = partsList["Concrete Pipe"];
PartFamily partFamily = (PartFamily)tr.GetObject(idPipe, OpenMode.ForWrite);
idPipeSize = partFamily[0];
PartSize partSize = (PartSize)tr.GetObject(idPipeSize, OpenMode.ForRead);
PartDataRecord pdr = partSize.SizeDataRecord;
PartDataField[] pdf = pdr.GetAllDataFields();
for (int i = 0; i < pdf.Length; i++)
{
System.Diagnostics.Debug.Print(string.Format("{0}: {1}", pdf[i].Description, pdf[i].Value.ToString()));
}
idStruct = partsList["Rectangular Structure Slab Top Rectangular Frame"];
partFamily = (PartFamily)tr.GetObject(idStruct, OpenMode.ForWrite);
idStructSize = partFamily[0];
double depth = -6, slope = 0, dZ = 0, top = 0;
double diam = double.Parse(pdf[0].Value.ToString()) / 12;
ObjectId idPipeNew = ObjectId.Null;
AlignmentEntity ent = null;
Structure sPrev = null;
uint pntNum = 0;
ObjectId idCgPntBeg, idCgPntEnd, idCgPntPrev = ObjectId.Null;
TypedValue[] tvs;
for (int i = 0; i < algnData.Count; i++)
{
if (algnData.Count == 1)
{
ent = ents[0];
}
else
{
ent = ents.EntityAtId(algnData[i].ID);
}
ObjectId idStructNew = ObjectId.Null;
Structure s = null;
Pipe p = null;
if (ent.EntityType == AlignmentEntityType.Line)
{
AlignmentLine line = (AlignmentLine)ent;
Point2d pnt2dBeg = line.StartPoint;
Point2d pnt2dEnd = line.EndPoint;
try
{
top = tinSurfDE.FindElevationAtXY(pnt2dBeg.X, pnt2dBeg.Y) + depth;
}
catch (System.Exception)
{
Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("Pipe endpoint is beyond limit of design surface");
return;
}
Point3d pnt3dBeg = new Point3d(pnt2dBeg.X, pnt2dBeg.Y, top);
try
{
top = tinSurfDE.FindElevationAtXY(pnt2dEnd.X, pnt2dEnd.Y) + depth;
}
catch (System.Exception)
{
Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("Pipe endpoint is beyond limit of design surface");
return;
}
Point3d pnt3dEnd = new Point3d(pnt2dEnd.X, pnt2dEnd.Y, top);
LineSegment3d seg3d = new LineSegment3d(pnt3dBeg, pnt3dEnd);
net.AddLinePipe(idPipe, idPipeSize, seg3d, ref idPipeNew, true);
p = (Pipe)idPipeNew.getEnt();
p.AddToProfileView(fMNP.idProfileView);
ObjectId idPart = getProfileViewPart();
slope = pnt3dBeg.getSlope(pnt3dEnd);
dZ = diam / (2 * (System.Math.Cos(System.Math.Atan(System.Math.Abs(slope)))));
if (i == 0)
{
pnt3dBeg = new Point3d(pnt3dBeg.X, pnt3dBeg.Y, pnt3dBeg.Z - dZ);
pnt3dEnd = new Point3d(pnt3dEnd.X, pnt3dEnd.Y, pnt3dEnd.Z - dZ);
idCgPntBeg = pnt3dBeg.setPoint(out pntNum, pntDesc);
idsCgPnt.Add(idCgPntBeg);
idCgPntEnd = pnt3dEnd.setPoint(out pntNum, pntDesc);
idsCgPnt.Add(idCgPntEnd);
idCgPntPrev = idCgPntEnd;
tvs = new TypedValue[3];
tvs.SetValue(new TypedValue(1001, apps.lnkMNP), 0);
tvs.SetValue(new TypedValue(1005, idCgPntBeg.getHandle().ToString()), 1);
tvs.SetValue(new TypedValue(1005, idCgPntEnd.getHandle().ToString()), 2);
//idPart.setXData(rb, apps.lnkMNP);
idPipeNew.setXData(tvs, apps.lnkMNP);
net.AddStructure(idStruct, idStructSize, pnt3dBeg, 0, ref idStructNew, true);
s = (Structure)idStructNew.getEnt();
s.AddToProfileView(fMNP.idProfileView);
s.ConnectToPipe(idPipeNew, ConnectorPositionType.Start);
net.AddStructure(idStruct, idStructSize, pnt3dEnd, 0, ref idStructNew, true);
s = (Structure)idStructNew.getEnt();
s.AddToProfileView(fMNP.idProfileView);
s.ConnectToPipe(idPipeNew, ConnectorPositionType.End);
sPrev = s;
hPipe.Add(idPipeNew.getHandle().ToString());
}
else
{
pnt3dEnd = new Point3d(pnt3dEnd.X, pnt3dEnd.Y, pnt3dEnd.Z - dZ);
idCgPntEnd = pnt3dEnd.setPoint(out pntNum, pntDesc);
idsCgPnt.Add(idCgPntEnd);
tvs = new TypedValue[3];
tvs.SetValue(new TypedValue(1001, apps.lnkMNP), 0);
tvs.SetValue(new TypedValue(1005, idCgPntPrev.getHandle().ToString()), 1);
tvs.SetValue(new TypedValue(1005, idCgPntEnd.getHandle().ToString()), 2);
//idPart.setXData(rb, apps.lnkMNP);
idPipeNew.setXData(tvs, apps.lnkMNP);
idCgPntPrev = idCgPntEnd;
net.AddStructure(idStruct, idStructSize, pnt3dEnd, 0, ref idStructNew, true);
s = (Structure)idStructNew.getEnt();
s.AddToProfileView(fMNP.idProfileView);
sPrev.ConnectToPipe(idPipeNew, ConnectorPositionType.Start);
s.ConnectToPipe(idPipeNew, ConnectorPositionType.End);
sPrev = s;
hPipe.Add(idPipeNew.getHandle().ToString());
}
}
else if (ent.EntityType == AlignmentEntityType.Arc)
{
AlignmentArc arc = (AlignmentArc)ent;
double radius = arc.Radius;
Point2d pnt2dBeg = arc.StartPoint;
Point2d pnt2dEnd = arc.EndPoint;
try
{
top = tinSurfDE.FindElevationAtXY(pnt2dBeg.X, pnt2dBeg.Y) + depth;
}
catch (System.Exception)
{
Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("Pipe endpoint is beyond limit of design surface");
return;
}
Point3d pnt3dBeg = new Point3d(pnt2dBeg.X, pnt2dBeg.Y, top);
try
{
top = tinSurfDE.FindElevationAtXY(pnt2dEnd.X, pnt2dEnd.Y) + depth;
}
catch (System.Exception)
{
Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("Pipe endpoint is beyond limit of design surface");
return;
}
IntPtr iptr = (IntPtr)0;
Point3d pnt3dEnd = new Point3d(pnt2dEnd.X, pnt2dEnd.Y, top);
Arc a = new Arc();
a.Radius = arc.Radius;
a.StartPoint = new Point3d(pnt2dBeg.X, pnt2dBeg.Y, 0);
a.EndPoint = new Point3d(pnt2dEnd.X, pnt2dEnd.Y, 0);
a.Center = new Point3d(arc.CenterPoint.X, arc.CenterPoint.Y, 0);
Curve3d c = (Curve3d)a.GetGeCurve();
net.AddCurvePipe(idPipe, idPipeSize, c, arc.Clockwise, ref idPipeNew, true);
p = (Pipe)idPipeNew.getEnt();
p.AddToProfileView(fMNP.idProfileView);
ObjectId idPart = getProfileViewPart();
slope = (pnt3dEnd.Z - pnt3dBeg.Z) / arc.Length;
dZ = diam / (2 * (System.Math.Cos(System.Math.Atan(System.Math.Abs(slope)))));
if (i == 0)
{
pnt3dBeg = new Point3d(pnt3dBeg.X, pnt3dBeg.Y, pnt3dBeg.Z - dZ);
pnt3dEnd = new Point3d(pnt3dEnd.X, pnt3dEnd.Y, pnt3dEnd.Z - dZ);
idCgPntBeg = pnt3dBeg.setPoint(out pntNum, pntDesc);
idsCgPnt.Add(idCgPntBeg);
idCgPntEnd = pnt3dEnd.setPoint(out pntNum, pntDesc);
idsCgPnt.Add(idCgPntEnd);
tvs = new TypedValue[3];
tvs.SetValue(new TypedValue(1001, apps.lnkMNP), 0);
tvs.SetValue(new TypedValue(1005, idCgPntBeg.getHandle().ToString()), 1);
tvs.SetValue(new TypedValue(1005, idCgPntEnd.getHandle().ToString()), 2);
//idPart.setXData(rb, apps.lnkMNP);
idPipeNew.setXData(tvs, apps.lnkMNP);
net.AddStructure(idStruct, idStructSize, pnt3dBeg, 0, ref idStructNew, true);
s = (Structure)tr.GetObject(idStructNew, OpenMode.ForWrite);
s.AddToProfileView(fMNP.idProfileView);
s.ConnectToPipe(idPipeNew, ConnectorPositionType.Start);
net.AddStructure(idStruct, idStructSize, pnt3dBeg, 0, ref idStructNew, true);
s = (Structure)tr.GetObject(idStructNew, OpenMode.ForWrite);
s.AddToProfileView(fMNP.idProfileView);
s.ConnectToPipe(idPipeNew, ConnectorPositionType.End);
sPrev = s;
hPipe.Add(idPipeNew.getHandle().ToString());
}
else
{
pnt3dEnd = new Point3d(pnt3dEnd.X, pnt3dEnd.Y, pnt3dEnd.Z - dZ);
idCgPntEnd = pnt3dEnd.setPoint(out pntNum, pntDesc);
idsCgPnt.Add(idCgPntEnd);
tvs = new TypedValue[3];
tvs.SetValue(new TypedValue(1001, apps.lnkMNP), 0);
tvs.SetValue(new TypedValue(1005, idCgPntPrev.getHandle().ToString()), 1);
tvs.SetValue(new TypedValue(1005, idCgPntEnd.getHandle().ToString()), 2);
//idPart.setXData(rb, apps.lnkMNP);
idPipeNew.setXData(tvs, apps.lnkMNP);
idCgPntPrev = idCgPntEnd;
net.AddStructure(idStruct, idStructSize, pnt3dBeg, 0, ref idStructNew, true);
s = (Structure)tr.GetObject(idStructNew, OpenMode.ForWrite);
s.AddToProfileView(fMNP.idProfileView);
sPrev.ConnectToPipe(idPipeNew, ConnectorPositionType.Start);
s.ConnectToPipe(idPipeNew, ConnectorPositionType.End);
sPrev = s;
hPipe.Add(idPipeNew.getHandle().ToString());
}
}
}
tr.Commit();
}
hPipe.Insert(0, "-1");
hPipe.Add("-1");
for (int i = 0; i < idsCgPnt.Count; i++)
{
TypedValue[] tvs = new TypedValue[3];
tvs.SetValue(new TypedValue(1001, apps.lnkMNP), 0);
tvs.SetValue(new TypedValue(1005, hPipe[i]), 1);
tvs.SetValue(new TypedValue(1005, hPipe[i + 1]), 2);
idsCgPnt[i].setXData(tvs, apps.lnkMNP);
}
}
