protected override void OnClick()
{
FileType ft = FileType.COGOToolbarTraverse; //start out assuming it is a cogo traverse file
m_count = 1;
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByName("esriCadastralUI.CadastralEditorExtension");
ICadastralFabric pCadFabric = pCadEd.CadastralFabric;
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)pCadEd;
IParcelEditManager pParcEditorMan = (IParcelEditManager)pCadEd;
IParcelConstruction pTrav = pParcEditorMan.ParcelConstruction;
if (!(pParcEditorMan.InTraverseEditMode) && !(pParcEditorMan.InConstructionEditMode))
{//if this is not a construction or a new parcel, then get out.
MessageBox.Show("Please create a new parcel or new construction first, and then try again.");
return;
}
//Make sure the lines grid is selected
Utilities UTILS = new Utilities();
UTILS.SelectCadastralPropertyPage((ICadastralExtensionManager)pCadExtMan, "lines");
IParcelConstruction3 pTrav3 = (IParcelConstruction3)pTrav;
IGSParcel pParcel = null;
try
{
pParcel = pTrav.Parcel;
}
catch (COMException error)
{
MessageBox.Show(error.Message.ToString());
return;
}
//go get a traverse file
// Display .Net dialog for File selection.
OpenFileDialog openFileDialog = new OpenFileDialog();
// Set File Filter
openFileDialog.Filter = "Traverse file (*.txt)|*.txt|Comma-delimited(*.csv)|*.csv|All Files|*.*";
// Disable multi-select
openFileDialog.Multiselect = false;
// Don't need to Show Help
openFileDialog.ShowHelp = false;
// Set Dialog Title
openFileDialog.Title = "Load file";
openFileDialog.FilterIndex = 2;
// Display Open File Dialog
if (openFileDialog.ShowDialog() != DialogResult.OK)
{
openFileDialog = null;
return;
}
TextReader tr = null;
try
{
tr = new StreamReader(openFileDialog.FileName);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
string sCourse = "";
int iCount = 0;
string[] sFileLine = new string[0]; //define as dynamic array
//initialize direction units and format
esriDirectionType enumDirectionType = esriDirectionType.esriDTQuadrantBearing;
esriDirectionUnits enumDirectionUnits = esriDirectionUnits.esriDUDegreesMinutesSeconds;
//initialize start and end points
IPoint StartPoint = new PointClass();
IPoint EndPoint = new PointClass();
bool IsLoopTraverse = false;
//fill the array with the lines from the file
while (sCourse != null)
{
sCourse = tr.ReadLine();
try
{
if (sCourse.Trim().Length >= 1) //test for empty lines
{
RedimPreserveString(ref sFileLine, 1);
sFileLine[iCount] = sCourse;
}
iCount++;
sCourse = sCourse.ToLower();
if (sCourse.Contains("dt"))
{
if (sCourse.Contains("qb"))
{
enumDirectionType = esriDirectionType.esriDTQuadrantBearing;
}
else if (sCourse.Contains("na"))
{
enumDirectionType = esriDirectionType.esriDTNorthAzimuth;
}
else if (sCourse.Contains("sa"))
{
enumDirectionType = esriDirectionType.esriDTSouthAzimuth;
}
else if (sCourse.Contains("p"))
{
enumDirectionType = esriDirectionType.esriDTPolar;
}
}
if (sCourse.Contains("du"))
{
if (sCourse.Contains("dms"))
{
enumDirectionUnits = esriDirectionUnits.esriDUDegreesMinutesSeconds;
}
else if (sCourse.Contains("dd"))
{
enumDirectionUnits = esriDirectionUnits.esriDUDecimalDegrees;
}
else if (sCourse.Contains("g"))
{
enumDirectionUnits = esriDirectionUnits.esriDUGons;
}
else if (sCourse.Contains("r"))
{
enumDirectionUnits = esriDirectionUnits.esriDURadians;
}
}
if (sCourse.Contains("sp"))
{//start point
string[] XY = sCourse.Split(' ');
double x = Convert.ToDouble(XY[1]);
double y = Convert.ToDouble(XY[2]);
StartPoint.PutCoords(x, y);
}
if (sCourse.Contains("ep"))
{//end point
string[] XY = sCourse.Split(' ');
double x = Convert.ToDouble(XY[1]);
double y = Convert.ToDouble(XY[2]);
EndPoint.PutCoords(x, y);
}
if (sCourse.Contains("tometricfactor"))
{//this handles the comma-separated file case
string[] sScaleFactor = sCourse.Split(',');
m_dScaleFactor = Convert.ToDouble(sScaleFactor[1]);
}
}
catch { }
}
tr.Close(); //close the file and release resources
string sFileExt = System.IO.Path.GetExtension(openFileDialog.FileName.TrimEnd());
if ((sFileExt.ToLower() == ".csv") && (sFileLine[0].Contains(",")))
{//if it's a comma-delimited file
ft = FileType.CommaDelimited;
}
//Test for loop traverse
if (!(EndPoint.IsEmpty))
{
if (EndPoint.Compare(StartPoint) == 0)
{
IsLoopTraverse = true;
}
else
{
IsLoopTraverse = false;
}
}
//get highest point id number in grid, and get the to point id on the last line.
IGSLine pParcelLine = null;
int iFirstToNode = -1;
int iLastToNode = -1;
int iHighestPointID = -1;
for (int i = 0; i < pTrav.LineCount; i++)
{
if (pTrav.GetLine(i, ref pParcelLine))
{
if (iFirstToNode < 0)
{
iFirstToNode = pParcelLine.ToPoint;
}
iLastToNode = pParcelLine.ToPoint;
iHighestPointID = iHighestPointID < pParcelLine.ToPoint ? pParcelLine.ToPoint : iHighestPointID;
iHighestPointID = iHighestPointID < pParcelLine.FromPoint ? pParcelLine.FromPoint : iHighestPointID;
}
}
ICadastralUndoRedo pCadUndoRedo = pTrav as ICadastralUndoRedo;
pCadUndoRedo.StartUndoRedoSession("Load Lines From File");
try
{
IGSLine pLine = null;
int iLinecount = iCount - 1;
ISegment pExitTangent = null;
for (iCount = 0; iCount <= iLinecount; iCount++)
{
if (ft == FileType.COGOToolbarTraverse)
{
{
pLine = null;
ICircularArc pCircArc;//need to use this in the test to handle curves greater than 180
pLine = CreateGSLine(sFileLine[iCount], enumDirectionUnits, enumDirectionType,
pExitTangent, out pExitTangent, out pCircArc);
//exit tangent from the previous course is the new entry tangent for the next course
if (pLine != null)
{
if (pCircArc == null)
{// straight line
//if this is the last course then set the to point to 1
if ((iCount == iLinecount) && IsLoopTraverse)
{
pLine.ToPoint = 1;
}
pTrav.InsertGridRow(-1, pLine);
}
else
{ //some post-processing needed to figure out if a 180 curve needs to be split
if (Math.Abs(pCircArc.CentralAngle) < (Math.PI - 0.000001)) //some tolerance for being close to 180
{ //this curve is OK
//if this is the last course then set the to point to 1
if ((iCount == iLinecount) && IsLoopTraverse)
{
pLine.ToPoint = 1;
}
pTrav.InsertGridRow(-1, pLine);
}
else
{//curve is greater than or equal to 180, special treatment for GSE needed to split curve into 2 parts
//first decrement the count
m_count -= 1;
ISegment pFullSegment = (ISegment)pCircArc; ISegment pFirstHalf; ISegment pSecondHalf;
pFullSegment.SplitAtDistance(0.5, true, out pFirstHalf, out pSecondHalf);
IConstructCircularArc2 pCircArcConstr1 = new CircularArcClass();
ICircularArc pCircArc1 = (ICircularArc)pCircArcConstr1;
pCircArcConstr1.ConstructEndPointsRadius(pFirstHalf.FromPoint,
pFirstHalf.ToPoint, pCircArc.IsCounterClockwise, pCircArc.Radius, true);
ILine2 pTangentLine = new LineClass();
pCircArc1.QueryTangent(esriSegmentExtension.esriExtendTangentAtTo, 0, false, 100, pTangentLine);
string sTangentBearing = PolarRadians_2_DirectionString(pTangentLine.Angle,
enumDirectionType, enumDirectionUnits);
sTangentBearing = sTangentBearing.Replace(" ", "");
string sHalfDelta = Radians_2_Angle(Math.Abs(pCircArc1.CentralAngle), enumDirectionUnits);
string sSide = pCircArc.IsCounterClockwise ? " L " : " R ";
ISegment EntryTangent = (ISegment)pTangentLine;
//construct the string for the first piece
// looks similar to this: NC R 500 D 181-59-59 T N59-59-59W L
string sFirstCurve = "NC R " + Convert.ToString(pCircArc.Radius)
+ " D " + sHalfDelta + " T " + sTangentBearing + sSide;
IGSLine pLineFirstCurve = CreateGSLine(sFirstCurve, enumDirectionUnits, enumDirectionType, pExitTangent,
out pExitTangent, out pCircArc);
pTrav.InsertGridRow(-1, pLineFirstCurve);
ICircularArc pCircArc2 = (ICircularArc)pCircArcConstr1;
pCircArcConstr1.ConstructEndPointsRadius(pSecondHalf.FromPoint,
pSecondHalf.ToPoint, pCircArc.IsCounterClockwise, pCircArc.Radius, true);
pCircArc2.QueryTangent(esriSegmentExtension.esriExtendTangentAtTo, 0, false, 100, pTangentLine);
sTangentBearing = PolarRadians_2_DirectionString(pTangentLine.Angle, enumDirectionType, enumDirectionUnits);
sTangentBearing = sTangentBearing.Replace(" ", "");
//construct the string for the second piece
// looks similar to this: NC R 500 D 181-59-59 T N59-59-59W L
string sSecondCurve = "NC R " + Convert.ToString(pCircArc.Radius)
+ " D " + sHalfDelta + " T " + sTangentBearing + sSide;
IGSLine pLineSecondCurve = CreateGSLine(sSecondCurve, enumDirectionUnits, enumDirectionType, pExitTangent,
out pExitTangent, out pCircArc);
//if this is the last course then set the to point to 1
if ((iCount == iLinecount) && IsLoopTraverse)
{
pLine.ToPoint = 1;
}
pTrav.InsertGridRow(-1, pLineSecondCurve);
}
}
}
}
}
else//this is comma-separated version of the grid, so do the following
{
pLine = null;
//apply a point id number offset if there are existing lines in the grid.
if (iHighestPointID > -1 && iCount >= 3)
{
string[] sTraverseCourse = sFileLine[iCount].Split(',');
if (iCount == 3)
{
sTraverseCourse[0] = iLastToNode.ToString();
sTraverseCourse[5] = (Convert.ToInt32(sTraverseCourse[5]) + iHighestPointID).ToString();
}
else if (iCount > 3)
{
sTraverseCourse[0] = (Convert.ToInt32(sTraverseCourse[0]) + iHighestPointID).ToString();
sTraverseCourse[5] = (Convert.ToInt32(sTraverseCourse[5]) + iHighestPointID).ToString();
}
sFileLine[iCount] = sTraverseCourse[0];
int iAttCount = sTraverseCourse.GetLength(0);
for (int j = 1; j < iAttCount; j++)
{
sFileLine[iCount] += "," + sTraverseCourse[j];
}
}
pLine = CreateGSLineFromCommaSeparatedString(sFileLine[iCount], enumDirectionUnits, enumDirectionType);
if (pLine != null)
{
pTrav.InsertGridRow(-1, pLine);
}
}
}
pTrav3.UpdateGridFromGSLines(false);
IParcelConstruction2 pConstr2 = (IParcelConstruction2)pTrav3; //hidden interface
pConstr2.RecalculatePoints(); //explicit recalculate needed on a construction
pParcel.Modified();
pParcEditorMan.Refresh();
pCadUndoRedo.WriteUndoRedoSession(true);
sFileLine = null;
openFileDialog = null;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Load Lines From File");
pCadUndoRedo.WriteUndoRedoSession(false);
}
}
protected override void OnClick()
{
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByName("esriCadastralUI.CadastralEditorExtension");
IParcelEditManager pParcEditorMan = (IParcelEditManager)pCadEd;
ICadastralPacketManager pCadPacketMan = (ICadastralPacketManager)pCadEd;
//bool bStartedWithPacketOpen = pCadPacketMan.PacketOpen;
if (pParcEditorMan == null)
{
return;
}
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
if (pEd.EditState == esriEditState.esriStateNotEditing)
{
MessageBox.Show("Please start editing and try again.");
return;
}
IParcelConstruction pConstr = pParcEditorMan.ParcelConstruction;
IParcelConstruction4 pConstr4 = pConstr as IParcelConstruction4;
ICadastralPoints pCadastralPts = pConstr4 as ICadastralPoints;
ICadastralEditorSettings2 pCadastralEditorSettings2 = pCadEd as ICadastralEditorSettings2;
ICadastralFixedPoints pFixedPoints = pCadastralPts as ICadastralFixedPoints;
IPointCalculation pPointCalc = new PointCalculationClass();
if (pConstr == null)
{
return;
}
IGSLine pParcelLine = null;
IMetricUnitConverter pMetricUnitConv = (IMetricUnitConverter)pCadEd;
IGSPoint pStartPoint = null;
List <int> lstPointIds = new List <int>();
List <IVector3D> Traverse = new List <IVector3D>();
//get rotation here
IParcelConstructionData pConstrData = pConstr4.ConstructionData;
IConstructionParentParcels pConstructionParentParcels = pConstrData as IConstructionParentParcels;
ICadastralUndoRedo pCadUndoRedo = pConstr as ICadastralUndoRedo;
try
{
int iParcelID = -1;
if (pConstructionParentParcels.ParentParcelCount > 0)
{
pConstructionParentParcels.GetParentParcel(0, ref iParcelID);
}
ICadastralParcel pCadaParcel = pCadPacketMan.JobPacket as ICadastralParcel;
IGSParcel pGSParcel = null;
if (pCadaParcel != null)
{
pGSParcel = pCadaParcel.GetParcel(iParcelID);
}
//if in measurement view then rotation is 0
double TheRotation = 0;
if (pGSParcel == null)
{
pGSParcel = pConstr.Parcel;
}
if (!pCadastralEditorSettings2.MeasurementView)
{
TheRotation = pGSParcel.Rotation;//radians
}
if (TheRotation == 123456789)
{
TheRotation = 0;
}
pPointCalc.Rotation = TheRotation;
IGSPoint pClosingPoint = null;
#region simple method as fall-back
bool bUseSimpleStackSelection = false;
if (bUseSimpleStackSelection)
{
//bool bLineSelectionSequence = false;
//IGSLine pLastSelectedGSLineInGrid = null;
//for (int i = 0; i < pConstr.LineCount; i++)
//{
// if (pConstr.GetLineSelection(i))
// {
// if (pConstr.GetLine(i, ref pParcelLine))
// {
// if (!bLineSelectionSequence) //first line
// {
// pStartPoint = pCadastralPts.GetPoint(pParcelLine.FromPoint);
// pToPoint = pCadastralPts.GetPoint(pParcelLine.ToPoint);
// }
// pPointCalc.AddLine(pParcelLine);
// pLastSelectedGSLineInGrid = pParcelLine;
// pToPoint = pCadastralPts.GetPoint(pParcelLine.ToPoint);
// lstPointIds.Add(pToPoint.Id);
// }
// bLineSelectionSequence = true;
// double dBear = pParcelLine.Bearing; //Azimuth of IVector3D is north azimuth radians zero degrees north
// double dDist = pParcelLine.Distance;
// IVector3D vec = new Vector3DClass();
// vec.PolarSet(dBear, 0, dDist); ////Azimuth of IVector3D is north azimuth radians zero degrees north
// Traverse.Add(vec);
// }
// else
// {
// if (bLineSelectionSequence && pConstr.GetLine(i, ref pParcelLine) && HasLineSelectionAfter(pConstr, i))
// //if there was a prior selection and this line is a complete line, and there is no later selection
// {
// MessageBox.Show("Please select a continuous set of lines for closure.");
// return;
// }
// }
//}
//pClosingPoint = pCadastralPts.GetPoint(pLastSelectedGSLineInGrid.ToPoint);
}
else
#endregion
{//build a forward star for the selected lines
IEnumCELines pCELines = new EnumCELinesClass();
IEnumGSLines pEnumGSLines = (IEnumGSLines)pCELines;
ILongArray pLongArray = new LongArrayClass();
int iFirstToNode = -1;
for (int i = 0; i < pConstr.LineCount; i++)
{
if (pConstr.GetLineSelection(i))
{
if (pConstr.GetLine(i, ref pParcelLine))
{
if (iFirstToNode < 0)
{
iFirstToNode = pParcelLine.ToPoint;
}
pLongArray.Add(i);
pCELines.Add(pParcelLine);
}
}
}
if (pCELines.Count == 0)
{
MessageBox.Show("No lines selected. Please select a continuous set of lines for closure." + Environment.NewLine +
"Line selection should not have branches.", "Traverse");
return;
}
IParcelLineFunctions3 ParcelLineFx = new ParcelFunctionsClass();
IGSForwardStar pFwdStar = ParcelLineFx.CreateForwardStar(pEnumGSLines);
//forward star object is now created for all the selected lines,
//need to first re-sequence the lines, and test for branching and discontinuity
int iBranches = 0; int iTracedLines = 0;
int iLoops = 0; int iTerminals = 0;
List <int> LineIDList = new List <int>();
List <int> FromList = new List <int>();
List <int> ToList = new List <int>();
List <string> FromToLine = new List <string>();
bool bTraceSucceeded = TraceLines(ref pFwdStar, iFirstToNode, ref iBranches, ref iTracedLines,
ref iLoops, ref iTerminals, ref FromToLine, ref FromList, ref ToList, 0);
if (iBranches > 0)
{
MessageBox.Show("Please select a continuous set of lines for closure." + Environment.NewLine +
"Line selection should not have branches.", "Traverse");
return;
}
if (iTracedLines < pLongArray.Count)
{
MessageBox.Show("Please select a continuous set of lines for closure." + Environment.NewLine +
"Selected Lines should be connected in a single sequence without branches.", "Traverse");
return;
}
//if it's a single loop check to see if the sequence needs to be reversed
//CW or CCW based on bearings
if (iLoops == 1)
{
bool bIsReversed = false;
foreach (int i in FromList)
{
if (i < 0)
{
bIsReversed = true;
}
else
{
bIsReversed = false;
break;
}
}
if (bIsReversed)
{//all courses are running reversed, so reverse the whole sequence
FromToLine.Clear();
FromList.Reverse();
ToList.Reverse();
int iNewFrom = -ToList[ToList.Count - 1];
int iNewTo = -FromList[ToList.Count - 1];
string sNewFromTo = iNewFrom.ToString() + "," + iNewTo.ToString();
FromToLine.Add(sNewFromTo);
for (int i = 1; i < ToList.Count; i++)
{
iNewFrom = -ToList[i - 1];
iNewTo = -FromList[i - 1];
sNewFromTo = iNewFrom.ToString() + "," + iNewTo.ToString();
FromToLine.Add(sNewFromTo);
}
}
}
LineIDList.Clear();
FromList.Clear();
ToList.Clear();
pLongArray.RemoveAll();
pCadUndoRedo.StartUndoRedoSession("Adjust Traverse");
if (iLoops == 0)
{
//re-sequence using TraceLines function based on either end point, because the order of
//selected construction lines in grid don't control start or end point
FromToLine.Clear();
int iTerminus = -1;
iTracedLines = 0;
iBranches = 0;
iLoops = 0; iTerminals = 0;
FindTerminusForSequence(ref pFwdStar, iFirstToNode, ref iTerminus, 0);
if (iTerminus == -1)
{
pCadUndoRedo.WriteUndoRedoSession(false);
return;
}
TraceLines(ref pFwdStar, iTerminus, ref iBranches, ref iTracedLines, ref iLoops, ref iTerminals,
ref FromToLine, ref FromList, ref ToList, 0);
}
List <IVector3D> SequencedTraverse = new List <IVector3D>();
IGSLine pGSLineInPath = null;
foreach (string s in FromToLine)
{
string[] sFromTo = s.Split(',');
int iFrom = Convert.ToInt32(sFromTo[0]);
int iTo = Convert.ToInt32(sFromTo[1]);
bool bReversed = pFwdStar.GetLine(iFrom, iTo, ref pGSLineInPath);
if (bReversed)
{
IGSLine pGSLine180 = new GSLineClass();
pGSLine180.FromPoint = pGSLineInPath.ToPoint;
pGSLine180.ToPoint = pGSLineInPath.FromPoint;
pGSLine180.Bearing = pGSLineInPath.Bearing + Math.PI;
pGSLine180.Distance = pGSLineInPath.Distance;
IVector3D vec180 = new Vector3DClass();
vec180.PolarSet(pGSLine180.Bearing, 0, pGSLine180.Distance); //Azimuth of IVector3D is north azimuth radians zero degrees north
Traverse.Add(vec180);
lstPointIds.Add(pGSLine180.ToPoint);
pPointCalc.AddLine(pGSLine180);
}
else
{
double dBear = pGSLineInPath.Bearing;
double dDist = pGSLineInPath.Distance;
IVector3D vec = new Vector3DClass();
vec.PolarSet(dBear, 0, dDist); //Azimuth of IVector3D is north azimuth radians zero degrees north
Traverse.Add(vec);
lstPointIds.Add(pGSLineInPath.ToPoint);
pPointCalc.AddLine(pGSLineInPath);
}
if (pStartPoint == null)
{
if (bReversed)
{
pStartPoint = pCadastralPts.GetPoint(pGSLineInPath.ToPoint);
}
else
{
pStartPoint = pCadastralPts.GetPoint(pGSLineInPath.FromPoint);
}
}
if (bReversed)
{
pClosingPoint = pCadastralPts.GetPoint(pGSLineInPath.FromPoint);
}
else
{
pClosingPoint = pCadastralPts.GetPoint(pGSLineInPath.ToPoint);
}
}
}
if (pStartPoint == null)
{
pCadUndoRedo.WriteUndoRedoSession(false);
return;
}
IPoint pStart = new PointClass();
pStart.X = pStartPoint.X;
pStart.Y = pStartPoint.Y;
string sAdjustMethod = "Compass";
esriParcelAdjustmentType eAdjMethod = esriParcelAdjustmentType.esriParcelAdjustmentCompass;
if (pCadastralEditorSettings2.ParcelAdjustment == esriParcelAdjustmentType.esriParcelAdjustmentNone ||
pCadastralEditorSettings2.ParcelAdjustment == esriParcelAdjustmentType.esriParcelAdjustmentCompass)
{
eAdjMethod = esriParcelAdjustmentType.esriParcelAdjustmentCompass;
}
else if (pCadastralEditorSettings2.ParcelAdjustment == esriParcelAdjustmentType.esriParcelAdjustmentCrandall)
{
sAdjustMethod = "Crandall";
eAdjMethod = pCadastralEditorSettings2.ParcelAdjustment;
}
else if (pCadastralEditorSettings2.ParcelAdjustment == esriParcelAdjustmentType.esriParcelAdjustmentTransit)
{
sAdjustMethod = "Transit";
eAdjMethod = pCadastralEditorSettings2.ParcelAdjustment;
}
pPointCalc.CalculatePoints(eAdjMethod, pStartPoint.Id, pStartPoint, pClosingPoint.Id, pClosingPoint, true);
ITraverseClosure pClose = pPointCalc.Closure;
List <string> lstCoursesFromTo = new List <string>();
List <IVector3D> AdjustedTraverse = new List <IVector3D>();
double dAdjustedPointX = 0; double dAdjustedPointY = 0;
double dPreviousPointX = 0; double dPreviousPointY = 0;
for (int i = 0; i < pClose.CourseCount; i++)
{
IGSPoint pPt = pCadastralPts.GetPoint(lstPointIds[i]);
dAdjustedPointY = pPointCalc.GetCalculatedPoint(lstPointIds[i], ref dAdjustedPointX);
string sFromTo = "";
IVector3D pAdjustedLine = new Vector3DClass();
if (i == 0)
{
sFromTo = pStartPoint.Id.ToString() + "-" + lstPointIds[i].ToString();
pAdjustedLine.SetComponents(dAdjustedPointX - pStartPoint.X, dAdjustedPointY - pStartPoint.Y, 0);
}
else
{
sFromTo = lstPointIds[i - 1].ToString() + "-" + lstPointIds[i].ToString();
pAdjustedLine.SetComponents(dAdjustedPointX - dPreviousPointX, dAdjustedPointY - dPreviousPointY, 0);
}
lstCoursesFromTo.Add(sFromTo);
IVector3D Z_Axis = new Vector3DClass();
Z_Axis.SetComponents(0, 0, 100);
pAdjustedLine.Rotate(TheRotation, Z_Axis);
AdjustedTraverse.Add(pAdjustedLine);
dPreviousPointX = dAdjustedPointX;
dPreviousPointY = dAdjustedPointY;
pPt.X = dAdjustedPointX;
pPt.Y = dAdjustedPointY;
if (!pCadastralEditorSettings2.MeasurementView)
{
pFixedPoints.SetFixedPoint(lstPointIds[i], true);
}
}
double dMisclosureDistance = pClose.MisclosureDistance; double dMisclosureBearing = pClose.MisclosureDirection;
IVector MiscloseVector = new Vector3DClass();
IEditProperties2 pEdProps = pEd as IEditProperties2;
IAngularConverter pAngConv = new AngularConverterClass();
pAngConv.SetAngle(dMisclosureBearing, esriDirectionType.esriDTNorthAzimuth, esriDirectionUnits.esriDURadians);
//int iPrec = 7;
//if (pConstr.Parcel.Plan.AngleUnits == esriDirectionUnits.esriDUDegreesMinutesSeconds)
// iPrec = 0;
string sMiscloseBearing = pAngConv.GetString(pEdProps.DirectionType, pEdProps.DirectionUnits, pEdProps.AngularUnitPrecision);
Utilities UTIL = new Utilities();
string sRatio = "High Accuracy";
if (pClose.RelativeErrorRatio < 10000)
{
sRatio = "1:" + pClose.RelativeErrorRatio.ToString("0");
}
if (dMisclosureDistance >= 0.001)
{
sMiscloseBearing = UTIL.FormatDirectionDashesToDegMinSecSymbols(sMiscloseBearing);
}
else
{
sMiscloseBearing = "----";
}
ICadastralUnitConversion pCadUnitConverter = new CadastralUnitConversionClass();
double dMetersPerUnit = pCadUnitConverter.ConvertDouble(1, pConstr.Parcel.Plan.DistanceUnits, esriCadastralDistanceUnits.esriCDUMeter);
string sReport = "Closure:" + Environment.NewLine +
" error: " + sRatio + Environment.NewLine +
" distance: " + (dMisclosureDistance / dMetersPerUnit).ToString("0.000") + Environment.NewLine +
" bearing: " + sMiscloseBearing + Environment.NewLine +
" xdist: " + (pClose.MisclosureX / dMetersPerUnit).ToString("0.000") + Environment.NewLine +
" ydist: " + (pClose.MisclosureY / dMetersPerUnit).ToString("0.000") + Environment.NewLine +
" courses: " + (pClose.CourseCount) + Environment.NewLine +
Environment.NewLine + "Adjustment:" + Environment.NewLine +
" method: " + sAdjustMethod;
dlgTraverseResults dlgTraverseResults = new dlgTraverseResults();
AddTraverseInfoToGrid(pConstr.Parcel.Plan, dlgTraverseResults.dataGridView1, Traverse, AdjustedTraverse, lstCoursesFromTo);
dlgTraverseResults.txtMiscloseReport.Text = sReport;
DialogResult dRes = dlgTraverseResults.ShowDialog();
if (dRes == DialogResult.Cancel)
{
//since we cancelled, set the points back
foreach (int i in lstPointIds)
{
pFixedPoints.SetFixedPoint(i, false);
}
pCadUndoRedo.WriteUndoRedoSession(false);
}
else
{
pCadUndoRedo.WriteUndoRedoSession(true);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + Environment.NewLine + "Line number:" + ex.LineNumber().ToString()
+ " in " + ex.TargetSite.Name, "Traverse");
pCadUndoRedo.WriteUndoRedoSession(false);
}
}
protected override void OnClick()
{
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByName("esriCadastralUI.CadastralEditorExtension");
IParcelEditManager pParcEditorMan = (IParcelEditManager)pCadEd;
ICadastralExtensionManager pCadMan = pCadEd as ICadastralExtensionManager;
ICadastralPacketManager pCadPacketMan = (ICadastralPacketManager)pCadEd;
//bool bStartedWithPacketOpen = pCadPacketMan.PacketOpen;
if (!(pCadMan.ContextItem is IGSLine))
{
return;
}
IGSLine pGSLine = pCadMan.ContextItem as IGSLine;
if (pParcEditorMan == null)
{
return;
}
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
if (pEd.EditState == esriEditState.esriStateNotEditing)
{
MessageBox.Show("Please start editing and try again.");
return;
}
IParcelConstruction pConstr = pParcEditorMan.ParcelConstruction;
ICadastralLinePoints2Ex pCadLPsEx = pConstr as ICadastralLinePoints2Ex;
ILongArray pLngArrBefore = pCadLPsEx.LinePoints;
List <int> lstLPBefore = new List <int>();
for (int i = 0; i < pLngArrBefore.Count; i++)
{
lstLPBefore.Add(pLngArrBefore.get_Element(i));
}
//first get the current set of breakpoints
Utilities FabUTILS = new Utilities();
FabUTILS.ExecuteCommand("{9987F18B-8CC4-4548-8C41-7DB51F289BB3}"); //Run COTS Breakline command
ILongArray pLngArrAfter = pCadLPsEx.LinePoints;
List <int> lstLPAfter = new List <int>();
for (int i = 0; i < pLngArrAfter.Count; i++)
{
lstLPAfter.Add(pLngArrAfter.get_Element(i));
}
List <int> lstNewBreakPoints = lstLPAfter.Except(lstLPBefore).ToList();
if (lstNewBreakPoints.Count == 0)
{
return;
}
IParcelConstruction4 pConstr4 = pConstr as IParcelConstruction4;
ICadastralPoints pCadastralPts = pConstr4 as ICadastralPoints;
IEnumCELines pCELines = new EnumCELinesClass();
IEnumGSLines pEnumGSLines = (IEnumGSLines)pCELines;
pCELines.Add(pGSLine);
//check if it's a construction line or parent line
bool bIsParentLine = true;
IEnumGSLines pEnumGSConstructionLines = pConstr4.GetLines(false, false);
IGSLine pGSTestLine = null;
IGSParcel pGSParc = null;
pEnumGSConstructionLines.Reset();
pEnumGSConstructionLines.Next(ref pGSParc, ref pGSTestLine);
while (pGSTestLine != null)
{
if ((pGSLine.FromPoint == pGSTestLine.FromPoint) && (pGSLine.ToPoint == pGSTestLine.ToPoint))
{
bIsParentLine = false;
break;
}
pEnumGSConstructionLines.Next(ref pGSParc, ref pGSTestLine);
}
IParcelLineFunctions3 pParcLineFunctions = new ParcelFunctionsClass();
IEnumGSLines pNewLinesEnum = pParcLineFunctions.BreakLinesAtLinePoints(pEnumGSLines, pCadastralPts, true, false);
IGSParcel pGSParcel = null;
IGSLine pGSNewLine = null;
ICadastralUndoRedo pCadUndoRedo = pConstr as ICadastralUndoRedo;
pCadUndoRedo.StartUndoRedoSession("Break-line");
pNewLinesEnum.Reset();
pNewLinesEnum.Next(ref pGSParcel, ref pGSNewLine);
while (pGSNewLine != null)
{
pConstr4.InsertGridRow(-1, pGSNewLine, true);
pNewLinesEnum.Next(ref pGSParcel, ref pGSNewLine);
}
ICadastralUnbuildableLines pUnbuildable = pConstr4 as ICadastralUnbuildableLines;
if (bIsParentLine)
{
pUnbuildable.AddLine(pGSLine);
}
else
{
pConstr4.Planarize(0.001); //delete the original construction line
}
pCadUndoRedo.WriteUndoRedoSession(true);
}