/// <summary> /// Initializes a new instance of the <see cref="IntersectDirectionAndDistanceOperation"/> class /// using the data read from persistent storage. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> internal IntersectDirectionAndDistanceOperation(EditDeserializer editDeserializer) : base(editDeserializer) { m_Direction = editDeserializer.ReadPersistent<Direction>(DataField.Direction); m_Distance = editDeserializer.ReadPersistent<Observation>(DataField.Distance); m_From = editDeserializer.ReadFeatureRef<PointFeature>(this, DataField.From); m_Default = editDeserializer.ReadBool(DataField.Default); FeatureStub to = editDeserializer.ReadPersistent<FeatureStub>(DataField.To); FeatureStub dirLine = editDeserializer.ReadPersistentOrNull<FeatureStub>(DataField.DirLine); FeatureStub distLine = editDeserializer.ReadPersistentOrNull<FeatureStub>(DataField.DistLine); DeserializationFactory dff = new DeserializationFactory(this); dff.AddFeatureStub(DataField.To, to); dff.AddFeatureStub(DataField.DirLine, dirLine); dff.AddFeatureStub(DataField.DistLine, distLine); ProcessFeatures(dff); }
/// <summary> /// Checks whether the current data is enough to construct a direction. /// If so, draw it. /// </summary> void OnNewDirection() { setDefaultOffsetButton.Enabled = CanSetDefaultOffset(); // Try to construct direction based on what's been entered Direction dir = GetCurrentDirection(); if (dir==null) { // If we didn't get anything, but we previously had a direction, ensure // it gets erased. if (m_Dir!=null) { m_Dir = null; ErasePainting(); } } else { // Just return if current direction matches what we've already got if (m_Dir!=null && m_Dir.IsEquivalent(dir)) return; // Draw the new direction m_Dir = dir; ErasePainting(); } }
/// <summary> /// Checks whether the current data is enough to construct a direction. If so, /// draw it. Take care to erase any previously drawn direction. /// </summary> void OnChange() { Direction dir=null; // Constructed direction. AngleDirection angle; // Angle from a backsight. DeflectionDirection deflect; // Deflection angle. BearingDirection bearing; // Bearing from north. ParallelDirection par; // Parallel to 2 points. double srad; // Signed radian value. // Apply sign to any angle we have. if (m_IsClockwise) srad = m_Radians; else srad = -m_Radians; if (m_Backsight!=null) { // If we have a backsight, we could either have a regular // angle or a deflection. To construct either, we need a // from-point as well. // Note that an angle of zero (passing through the backsight // or foresight) is fine. if (m_From!=null) { IAngle obsv = new RadianValue(srad); if (m_IsDeflection) { deflect = new DeflectionDirection(m_Backsight, m_From, obsv); dir = deflect; } else { angle = new AngleDirection(m_Backsight, m_From, obsv); dir = angle; } } } else if (m_From!=null) { // No backsight, so we could have either a bearing, // or a direction defined using 2 parallel points. // Since a bearing of zero is quite valid, we check // the dialog field to see if this is an entered value, // or just the initial value. if (m_Par1!=null && m_Par2!=null) { par = new ParallelDirection(m_From, m_Par1, m_Par2); dir = par; } else { if (m_Radians>Constants.TINY || angleTextBox.Text.Trim().Length==0) { bearing = new BearingDirection(m_From, new RadianValue(srad)); dir = bearing; } } } // If we have formed a direction, apply any offset. if (dir!=null) dir.Offset = m_Offset; // Try to calulate the position of the sideshot. IPosition to = RadialOperation.Calculate(dir, this.Length); // Return if we calculated a position that is identical to the old one. //if (to!=null && to.IsAt(m_To, Double.Epsilon)) // return; m_Dir = dir; m_To = to; m_Cmd.ErasePainting(); }
/// <summary> /// Displays any offset info for a direction. /// </summary> /// <param name="dir">The direction that may have an offset.</param> void ShowOffset(Direction dir) { // Initialize offset-related data members. m_IsRight = true; m_OffsetDistance = null; m_OffsetPoint = null; // Return if there is no offset. Offset offset = dir.Offset; if (offset==null) return; // It could be one of 2 types of offset. if (offset is OffsetDistance) { OffsetDistance dist = (offset as OffsetDistance); // Display the offset distance, in the current data entry units. // Setting the window text will end up calling OnChangeOffset, // which calls OnOffsetDistance, where it will be deduced that // we have an offset to the right. This may or may not be correct. m_OffsetDistance = dist.Offset; DistanceUnit entry = EditingController.Current.EntryUnit; offsetTextBox.Text = m_OffsetDistance.Format(entry, true); // Override whatever we got above. m_IsRight = dist.IsRight; if (m_IsRight) SetOffsetRight(); else SetOffsetLeft(); } else { // It SHOULD be an offset point. OffsetPoint point = (offset as OffsetPoint); if (point!=null) { // Display the ID of the offset point. m_OffsetPoint = point.Point; ShowKey(offsetTextBox, m_OffsetPoint); // Disable (and turn off) the radio buttons to allow right or left specification. TurnRadioOff(leftRadioButton); TurnRadioOff(rightRadioButton); } else MessageBox.Show("GetDirectionControl.ShowOffset - Unexpected type of offset."); } }
/// <summary> /// Default constructor /// </summary> public GetDirectionControl() { InitializeComponent(); m_DefaultOffset = null; m_Backsight = null; m_From = null; m_Par1 = null; m_Par2 = null; m_Radians = 0.0; m_IsDeflection = false; m_IsClockwise = true; m_OffsetDistance = null; m_IsRight = true; m_OffsetPoint = null; m_LineType = null; m_Dir = null; m_Circles = new List<Circle>(); m_WantCentre = false; m_Focus = null; }
/// <summary> /// Initializes a new instance of the <see cref="IntersectTwoDirectionsOperation"/> class. /// </summary> /// <param name="dir1">The first observed direction</param> /// <param name="dir2">The second observed direction</param> internal IntersectTwoDirectionsOperation(Direction dir1, Direction dir2) : base() { m_Direction1 = dir1; m_Direction2 = dir2; }
/// <summary> /// Displays info for a direction angle. /// </summary> /// <param name="dir">The direction to show.</param> void ShowAngle(Direction dir) { AngleDirection angle = (dir as AngleDirection); if (angle==null) return; // There should be no parallel points. m_Par1 = m_Par2 = null; // Get the backsight m_Backsight = angle.Backsight; ShowKey(backsightTextBox, m_Backsight); // Define the observed angle. m_Radians = angle.ObservationInRadians; m_IsClockwise = (m_Radians>=0.0); m_Radians = Math.Abs(m_Radians); string dirstr = RadianValue.AsString(m_Radians); if (angle is DeflectionDirection) dirstr += "d"; directionTextBox.Text = dirstr; // Indicate whether it's clockwise or otherwise. clockwiseRadioButton.Enabled = counterClockwiseRadioButton.Enabled = true; if (m_IsClockwise) { clockwiseRadioButton.Checked = true; //counterClockwiseRadioButton.Checked = false; } else { //clockwiseRadioButton.Checked = false; counterClockwiseRadioButton.Checked = true; } }
/// <summary> /// Intersects this direction with another direction. /// </summary> /// <param name="other">The other direction.</param> /// <returns>The calculated intersection (null if it doesn't exist)</returns> internal IPosition Intersect(Direction other) { // Get the starting positions for the two directions (may be offset). IPosition from1 = this.StartPosition; IPosition from2 = other.StartPosition; // Get the two directions in the form of a bearing. double b1 = this.Bearing.Radians; double b2 = other.Bearing.Radians; // The equation of each line is given in parametric form as: // // x = xo + f * r // y = yo + g * r // // where xo,yo is the from point // and f = sin(bearing) // and g = cos(bearing) // and r is the position ratio double cosb1 = Math.Cos(b1); double sinb1 = Math.Sin(b1); double cosb2 = Math.Cos(b2); double sinb2 = Math.Sin(b2); double f1g2 = sinb1 * cosb2; double f2g1 = sinb2 * cosb1; double det = f2g1 - f1g2; // Check whether lines are parallel. if (Math.Abs(det) < Double.Epsilon) return null; // Work out the intersection. double yo = from1.Y; double xo = from1.X; double dy = from2.Y - yo; double dx = from2.X - xo; double prat = (sinb2*dy - cosb2*dx)/det; return new Position((xo+sinb1*prat), (yo+cosb1*prat)); }
/// <summary> /// Relational equality test. When comparing any offsets, it's the actual ground /// dimension of the offset we're concerned with -- NOT the address of the offset, /// or the way it was specified (i.e. an offset can be the same, even if one is /// an OffsetDistance, and the other is an OffsetPoint). /// /// The result of the comparison is from the Direction class & down. Directions will /// compare the same, even if the info in parent classes is different. /// </summary> /// <param name="other">The direction to compare with</param> /// <returns></returns> internal bool IsEquivalent(Direction other) { // Check the simple fields. if (this.GetType() != other.GetType()) return false; // If one direction has an offset & the other doesn't, the directions are different. if ( (m_Offset!=null && other.m_Offset==null) || (m_Offset==null && other.m_Offset!=null) ) return false; // If BOTH offsets are defined, see if they are equivalent. if (m_Offset!=null && other.m_Offset!=null ) { // It is assumed that the point from which the direction // was measured has already been checked by the operator== // function in derived sub-classes. // Get the (signed) offsets, in meters on the ground. double offThis = m_Offset.GetMetric(this); double offThat = other.m_Offset.GetMetric(other); // The sign matters. if ((offThis<0.0 && offThat>=0.0) || (offThis>=0.0 && offThat<0.0)) return false; // Same sign, so if the offsets are the same, they should subtract to zero. if (Math.Abs(offThis-offThat) > Double.Epsilon) return false; } // Return the result of comparing the two derived classes. // ...not sure what's going on here... (shouldn't this just call an abstract method? -- maybe // needs to be a templated method, since both types need to be the same. if (this is AngleDirection || this is DeflectionDirection) { AngleDirection rThis = (AngleDirection)this; AngleDirection rThat = (AngleDirection)other; return rThis.Equals(rThat); } else if (this is BearingDirection) { BearingDirection rThis = (BearingDirection)this; BearingDirection rThat = (BearingDirection)other; return rThis.Equals(rThat); } else if (this is ParallelDirection) { ParallelDirection rThis = (ParallelDirection)this; ParallelDirection rThat = (ParallelDirection)other; return rThis.Equals(rThat); } return false; }
/// <summary> /// Calculates the intersection point. /// </summary> /// <param name="dir">Direction observation.</param> /// <param name="dist">Distance observation.</param> /// <param name="from">The point the distance was observed from.</param> /// <param name="usedefault">True if the default intersection is required (the one /// closer to the origin of the direction line). False for the other one (if any).</param> /// <returns>The position of the intersection (null if it cannot be calculated).</returns> IPosition Calculate(Direction dir, Observation distance, PointFeature from, bool usedefault) { // Call the static function that is also used by the dialog. IPosition xsect, x1, x2; if (Calculate(dir, distance, from, usedefault, out xsect, out x1, out x2)) return xsect; else return null; }
/// <summary> /// Initializes a new instance of the <see cref="IntersectDirectionAndDistanceOperation"/> class /// </summary> /// <param name="dir">Direction observation.</param> /// <param name="dist">Distance observation.</param> /// <param name="from">The point the distance was observed from.</param> /// <param name="usedefault">True if the default intersection is required (the one /// closer to the origin of the direction line). False for the other one (if any).</param> internal IntersectDirectionAndDistanceOperation(Direction dir, Observation dist, PointFeature from, bool useDefault) : base() { m_Direction = dir; m_Distance = dist; m_From = from; m_Default = useDefault; }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dist1">1st distance observation.</param> /// <param name="from1">The point the 1st distance was observed from.</param> /// <param name="dist2">2nd distance observation.</param> /// <param name="from2">The point the 2nd distance was observed from.</param> /// <param name="isdefault">True if the default intersection is required (the one that has the /// lowest bearing with respect to the 2 from points). False for the other one (if any).</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir, Observation distance, PointFeature from, bool isdefault) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation<Direction>(DataField.Direction, m_Direction, dir); result.AddObservation<Observation>(DataField.Distance, m_Distance, distance); result.AddFeature<PointFeature>(DataField.From, m_From, from); result.AddItem<bool>(DataField.Default, m_Default, isdefault); return result; }
/// <summary> /// Calculates the intersection point. /// </summary> /// <param name="dir">Direction observation.</param> /// <param name="distance">Distance observation.</param> /// <param name="from">The point the distance was observed from.</param> /// <param name="usedefault">True if the default intersection is required (the one /// closer to the origin of the direction line). False for the other one (if any).</param> /// <param name="xsect">The position of the intersection (if any).</param> /// <param name="xsect1">The 1st choice intersection (if any).</param> /// <param name="xsect2">The 2nd choice intersection (if any).</param> /// <returns>True if intersections were calculated. False if the distance circles /// don't intersect.</returns> internal static bool Calculate(Direction dir, Observation distance, PointFeature from, bool usedefault, out IPosition xsect, out IPosition xsect1, out IPosition xsect2) { // Initialize intersection positions. xsect = xsect1 = xsect2 = null; // Get the distance. double dist = distance.GetDistance(from).Meters; if (dist < Constants.TINY) return false; // Form circle with a radius that matches the observed distance. ICircleGeometry circle = new CircleGeometry(from, dist); // See if there is actually an intersection between the direction & the circle. IPosition x1, x2; uint nx = dir.Intersect(circle, out x1, out x2); if (nx==0) return false; // If we have 2 intersections, and we need the non-default one, pick up the 2nd // intersection. If only 1 intersection, use that, regardless of the setting for // the "use default" flag. if (nx==2 && !usedefault) xsect = x2; else xsect = x1; // Return if the distance is an offset point. OffsetPoint offset = (distance as OffsetPoint); if (offset!=null) { xsect1 = x1; xsect2 = x2; return true; } // Reduce observed distance to the mapping plane. ISpatialSystem sys = CadastralMapModel.Current.SpatialSystem; dist = dist * sys.GetLineScaleFactor(from, xsect); // And calculate the exact intersection (like above)... // Form circle with a radius that matches the reduced distance. ICircleGeometry circlep = new CircleGeometry(from, dist); // See if there is actually an intersection between the direction & the circle. nx = dir.Intersect(circlep, out x1, out x2); if (nx==0) return false; // If we have 2 intersections, and we need the non-default one, pick up the 2nd // intersection. If only 1 intersection, use that, regardless of the setting for // the "use default" flag. if (nx==2 && !usedefault) xsect = x2; else xsect = x1; xsect1 = x1; xsect2 = x2; return true; }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_Direction = data.ExchangeObservation<Direction>(this, DataField.Direction, m_Direction); m_Distance = data.ExchangeObservation<Observation>(this, DataField.Distance, m_Distance); m_From = data.ExchangeFeature<PointFeature>(this, DataField.From, m_From); m_Default = data.ExchangeValue<bool>(DataField.Default, m_Default); AssignObservedLengths(); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dir1">1st direction observation.</param> /// <param name="dir2">2nd direction observation.</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir1, Direction dir2) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation<Direction>(DataField.Direction1, m_Direction1, dir1); result.AddObservation<Direction>(DataField.Direction2, m_Direction2, dir2); return result; }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_Direction = data.ExchangeObservation<Direction>(this, DataField.Direction, m_Direction); m_Length = data.ExchangeObservation<Observation>(this, DataField.Length, m_Length); if (m_Line != null) m_Line.ObservedLength = (m_Length as Distance); }
/// <summary> /// Reads data that was previously written using <see cref="WriteData"/> /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <param name="dir1">The first observed direction.</param> /// <param name="dir2">The second observed direction</param> /// <param name="to">The created intersection point.</param> /// <param name="line1">The first line created (if any).</param> /// <param name="line1">The second line created (if any).</param> static void ReadData(EditDeserializer editDeserializer, out Direction dir1, out Direction dir2, out FeatureStub to, out FeatureStub line1, out FeatureStub line2) { dir1 = editDeserializer.ReadPersistent<Direction>(DataField.Direction1); dir2 = editDeserializer.ReadPersistent<Direction>(DataField.Direction2); to = editDeserializer.ReadPersistent<FeatureStub>(DataField.To); line1 = editDeserializer.ReadPersistentOrNull<FeatureStub>(DataField.Line1); line2 = editDeserializer.ReadPersistentOrNull<FeatureStub>(DataField.Line2); }
/// <summary> /// Calculates the position of the sideshot point. /// </summary> /// <param name="dir">The direction observation (if any).</param> /// <param name="len">The length observation (if any). Could be a <c>Distance</c> or an /// <c>OffsetPoint</c>.</param> /// <returns>The position of the sideshot point (null if there is insufficient data /// to calculate a position)</returns> internal static IPosition Calculate(Direction dir, Observation len) { // Return if there is insufficient data. if (dir == null || len == null) return null; // Get the position of the point the sideshot should radiate from. PointFeature from = dir.From; // Get the position of the start of the direction line (which may be offset). IPosition start = dir.StartPosition; // Get the bearing of the direction. double bearing = dir.Bearing.Radians; // Get the length of the sideshot arm. double length = len.GetDistance(from).Meters; // Calculate the resultant position. Note that the length is the length along the // bearing -- if an offset was specified, the actual length of the line from-to = // sqrt(offset*offset + length*length) IPosition to = Geom.Polar(start, bearing, length); // Return if the length is an offset point. In that case, the length we have obtained // is already a length on the mapping plane, so no further reduction should be done // (although it's debateable). if (len is OffsetPoint) return to; // Using the position we've just got, reduce the length we used to a length on the // mapping plane (it's actually a length on the ground). ISpatialSystem sys = CadastralMapModel.Current.SpatialSystem; double sfac = sys.GetLineScaleFactor(start, to); return Geom.Polar(start, bearing, length * sfac); }
/// <summary> /// Displays info for a specific direction and line. /// </summary> /// <param name="dir">The direction to show.</param> /// <param name="line">The line to show (null if there is no line).</param> void Show(Direction dir, LineFeature line) { // If we have a line, define its entity type and scroll the // entity combo box to that type. Note that when the string // is selected, it is important that m_Dir is null; otherwise // <mf CdGetDir::OnSelChangeLineType> may automatically move // on to the next page of the wizard dialog. m_LineType = (line==null ? null : line.EntityType); lineTypeComboBox.SelectEntity(m_LineType); // Define the from-point of the direction. m_From = dir.From; ShowKey(fromPointTextBox, m_From); // Ensure we've got any circle info. GetCircles(); // Does the direction have an offset? Offset offset = dir.Offset; if (offset!=null) ShowOffset(dir); // The rest depends on what sort of direction we have. if (dir is BearingDirection) ShowBearing(dir); else if (dir is AngleDirection) // Deflection too ShowAngle(dir); else if (dir is ParallelDirection) ShowParallel(dir); else MessageBox.Show("GetDirectionControl.Show - Cannot display direction info."); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dir">The direction (could contain an offset).</param> /// <param name="length">The length of the sideshot arm (either a <see cref="Distance"/> /// or an <see cref="OffsetPoint"/>).</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir, Observation length) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation<Direction>(DataField.Direction, m_Direction, dir); result.AddObservation<Observation>(DataField.Length, m_Length, length); return result; }
/// <summary> /// Displays info for a direction bearing. /// </summary> /// <param name="dir">The direction to show.</param> void ShowBearing(Direction dir) { BearingDirection bearing = (dir as BearingDirection); if (bearing==null) return; // There should be nothing in the backsight field. m_Backsight = m_Par1 = m_Par2 = null; // Define the bearing. m_Radians = bearing.Bearing.Radians; directionTextBox.Text = RadianValue.AsString(m_Radians); // Always comes back clockwise. m_IsClockwise = true; clockwiseRadioButton.Enabled = counterClockwiseRadioButton.Enabled = true; counterClockwiseRadioButton.Checked = false; clockwiseRadioButton.Checked = true; }
/// <summary> /// Initializes a new instance of the <see cref="RadialOperation"/> class. /// </summary> /// <param name="dir">The direction (could contain an offset).</param> /// <param name="length">The length of the sideshot arm (either a <see cref="Distance"/> or /// an <see cref="OffsetPoint"/>).</param> internal RadialOperation(Direction dir, Observation length) : base() { m_Direction = dir; m_Length = length; }
/// <summary> /// Displays info for a direction defined as parallel to 2 other points. /// </summary> /// <param name="dir">The direction to show.</param> void ShowParallel(Direction dir) { ParallelDirection par = (dir as ParallelDirection); if (par==null) return; // Pick up the points that define the parallel. m_Par1 = par.Start; m_Par2 = par.End; // Display the IDs of the 2 points. directionTextBox.Text = String.Format("{0}->{1}", m_Par1.FormattedKey, m_Par2.FormattedKey); // Disallow the ability to say whether the direction is clockwise or otherwise. TurnRadioOff(clockwiseRadioButton); TurnRadioOff(counterClockwiseRadioButton); // The angle value should be undefined. m_Radians = 0.0; m_IsClockwise = true; }
/// <summary> /// Initializes a new instance of the <see cref="RadialOperation"/> class /// using the data read from persistent storage. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> internal RadialOperation(EditDeserializer editDeserializer) : base(editDeserializer) { m_Direction = editDeserializer.ReadPersistent<Direction>(DataField.Direction); m_Length = editDeserializer.ReadPersistent<Observation>(DataField.Length); DeserializationFactory dff = new DeserializationFactory(this); dff.AddFeatureStub(DataField.To, editDeserializer.ReadPersistent<FeatureStub>(DataField.To)); dff.AddFeatureStub(DataField.Line, editDeserializer.ReadPersistentOrNull<FeatureStub>(DataField.Line)); ProcessFeatures(dff); }
/// <summary> /// Initializes dialog for an update. /// </summary> /// <param name="op">The edit that is being updated or recalled</param> /// <param name="dir">The direction number (1 or 2). A value of 2 is only /// valid when dealing with the <see cref="IntersectTwoDirectionsForm"/> dialog.</param> /// <returns>True if update (or recalled command) was shown.</returns> bool ShowUpdate(IntersectOperation op, byte dir) { /* // Return if no update feature (and no recall op). const CeIntersect* pop = GetUpdateOp(); if ( pop==0 ) pop = GetRecall(); if ( !pop ) return FALSE; */ if (op==null) return false; // Ensure that there is no direction line. If you don't do // this, it is possible that when we select a string in the // entity combo, we'll move directly to the next page of the // dialog (see <mf CdGetDir::OnSelChangeLineType>). m_Dir = null; // Populate the dialog, depending on what sort of operation we have. if (op.EditId == EditingActionId.DirIntersect) { Debug.Assert(dir==1 || dir==2); IntersectTwoDirectionsOperation oper = (IntersectTwoDirectionsOperation)op; if (dir==1) Show(oper.Direction1, oper.CreatedLine1); else Show(oper.Direction2, oper.CreatedLine2); } else if (op.EditId == EditingActionId.DirDistIntersect) { IntersectDirectionAndDistanceOperation oper = (IntersectDirectionAndDistanceOperation)op; Show(oper.Direction, oper.CreatedDirectionLine); } else if (op.EditId == EditingActionId.DirLineIntersect) { IntersectDirectionAndLineOperation oper = (IntersectDirectionAndLineOperation)op; Show(oper.Direction, oper.CreatedDirectionLine); } else { MessageBox.Show("GetDirectionControl.ShowUpdate - Unexpected editing operation"); } // Ensure everything is drawn ok. // this->OnDrawAll(); // Disallow change of line type (you cannot add or delete lines via update). lineTypeGroupBox.Enabled = false; return true; }
/// <summary> /// Returns the offset distance with respect to a reference direction, in meters /// on the ground. Offsets to the left are returned as a negated value, while /// offsets to the right are positive values. /// </summary> /// <param name="dir">The direction that the offset was observed with respect to.</param> /// <returns>The signed offset distance, in meters on the ground.</returns> internal override double GetMetric(Direction dir) { // In the case of an offset distance, the reference direction // is not actually required to get the offset (it is required // as a parameter only because the base class defines a pure // virtual this way). return this.Meters; }
private void Zero() { m_Cmd = null; m_Recall = null; m_From = null; m_Backsight = null; m_Par1 = null; m_Par2 = null; m_Radians = 0.0; m_IsClockwise = true; m_IsDeflection = false; m_Length = new Distance(); m_LengthOffset = null; m_DialOff = null; m_Offset = null; m_Dir = null; m_To = null; m_Circles = new List<Circle>(); m_Focus = null; m_WantLine = false; m_WantCentre = false; m_IsStatic = false; m_PointId = null; }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_Direction1 = data.ExchangeObservation<Direction>(this, DataField.Direction1, m_Direction1); m_Direction2 = data.ExchangeObservation<Direction>(this, DataField.Direction2, m_Direction2); }
/// <summary> /// Returns the offset distance with respect to a reference direction, in meters /// on the ground. Offsets to the left are returned as a negated value, while /// offsets to the right are positive values. /// </summary> /// <param name="dir">The direction that the offset was observed with respect to.</param> /// <returns>The signed offset distance, in meters on the ground</returns> internal abstract double GetMetric(Direction dir);
/// <summary> /// Returns the offset distance with respect to a reference direction, in meters /// on the ground. Offsets to the left are returned as a negated value, while /// offsets to the right are positive values. /// </summary> /// <param name="dir">The direction that the offset was observed with respect to.</param> /// <returns>The signed offset distance, in meters on the ground</returns> internal override double GetMetric(Direction dir) { // Return offset of zero if there is no offset point. if (m_Point==null) return 0.0; // Get the origin of the direction & it's bearing. This gives // us the info we need to express the equation of the line // in parametric form. PointFeature from = dir.From; double x = from.X; double y = from.Y; double bearing = dir.Bearing.Radians; // Get the position of the offset point. double xoff = m_Point.X; double yoff = m_Point.Y; // Get the signed perpendicular distance from the offset // point to the reference direction. return BasicGeom.SignedDistance(x, y, bearing, xoff, yoff); }