void OnBeforeStopParcelEditing()
{
if (m_ParcelEditHelperExt.RecordToField)
{
return;
}
IParcelConstruction4 pTrav = (IParcelConstruction4)m_pParcEditorMan.ParcelConstruction;
IEnumGSLines pGSLines = pTrav.GetLines(false, false);
pGSLines.Reset();
IGSLine pGSLine = null;
IGSParcel pGSParcel = null;
pGSLines.Next(ref pGSParcel, ref pGSLine);
while (pGSLine != null)
{
IGSAttributes pLineAtts = (IGSAttributes)pGSLine;
double brgRecord = Convert.ToDouble(pGSLine.Bearing);
brgRecord = brgRecord * 180 / Math.PI;
pLineAtts.SetProperty(m_ParcelEditHelperExt.FieldName, brgRecord);
//pGSParcel.Modified();
pGSLines.Next(ref pGSParcel, ref pGSLine);
}
pTrav.UpdateGridFromGSLines(true, false);
}
object OnGridCellEdit(ref int row, ref int col, ref object inValue)
{
string m_sFieldName = m_ParcelEditHelperExt.FieldName;
bool m_bRecordFieldName = m_ParcelEditHelperExt.RecordToField;
object OutValue = inValue;
if (col == 2 && m_bRecordFieldName)//this is the bearing field
{
IParcelConstruction pTrav = (IParcelConstruction)m_pParcEditorMan.ParcelConstruction;
IGSLine pGSLine = null;
bool IsCompleteLine = (pTrav.GetLine(row, ref pGSLine));
//true means it's a complete line
//false means it's a partial line
//note that the type of the inValue must be honoured when returning the value from this function, in this case we are rebuilding the string for the same value, unaltered.
//however the other relevant work done is to set the record field to the same value to capture what was entered prior to resequencing and potential bearing changes.
//this happens either for a complete line or a partial one
//The logic could be changed to be more conservative and only capture the record for a partial line (IsCompleteLine==false), since that would only record the first time it's cogo'd,
//compared to this code that records edits of completed lines *as well as* partial lines
IAngularConverter pAngConv = new AngularConverterClass();
string sBear = Convert.ToString(inValue);
sBear = sBear.Replace("°", "-");
sBear = sBear.Replace("'", "-");
sBear = sBear.Replace("\"", "");
if (!pAngConv.SetString(sBear, esriDirectionType.esriDTQuadrantBearing, esriDirectionUnits.esriDUDegreesMinutesSeconds)) //TODO: base this on Plan properties
{
return(OutValue);
}
double brgRecord = pAngConv.GetAngle(esriDirectionType.esriDTNorthAzimuth, esriDirectionUnits.esriDUDecimalDegrees);
sBear = pAngConv.GetString(esriDirectionType.esriDTQuadrantBearing, esriDirectionUnits.esriDUDegreesMinutesSeconds, 0);
IParcelConstruction4 pTrav4 = pTrav as IParcelConstruction4;
pTrav4.UpdateGridFromGSLines(true, false);
sBear = sBear.Replace(" ", "");
sBear = sBear.Insert(sBear.Length - 1, "\"");
int i = sBear.LastIndexOf('-');
sBear = sBear.Insert(i, "'");
i = sBear.IndexOf('-');
sBear = sBear.Insert(i, "°");
sBear = sBear.Replace("-", "");
IGSAttributes pLineAtts = (IGSAttributes)pGSLine;
pLineAtts.SetProperty(m_sFieldName, sBear);
return(sBear);
//note that the type of the inValue must be honoured when returning the value from this function.
}
return(OutValue);
}
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);
}
