# IConstructPoint Interface

Provides access to members that construct a point using other geometries and measures.

## Members

Name Description ConstructAlong Constructs a point distance units along the input curve. ConstructAngleBisector Constructs a point on the bisector of the angle (from, through, to). When useAcuteAngle is false, the sign of distance will select a point right or left of (from, through, to). Otherwise, the sign of distance will select the acute/obtuse point. ConstructAngleDistance Constructs a point at a specified angle (in radians) from the horizontal axis and a specified distance away from the input point. ConstructAngleIntersection Constructs the point of intersection between two lines defined by the input points and angles (in radians). ConstructDeflection Constructs a point in the polar coordinate system defined by baseLine and its 'from' point. The angle is in radians. ConstructDeflectionIntersection Constructs the point of intersection of two rays with origins at the endpoints of the base line and the specified angles (in radians). If onRightSide is true, this work will be done to the right of the base line, otherwise to the left. ConstructOffset Constructs a point distance units along the input curve and offset units perpendicularly away from it. ConstructParallel Constructs a point distance units from start, parallel to the tangent at the point nearest to start on the (extended) segment. ConstructPerpendicular Constructs a point 'distance' units from p and lying along the line normal to base and passing through p. ConstructThreePointResection Constructs the point of observation from which two signed angles between three points were measured; returns an angle which can help establish the confidence of the observation location: A small angle indicates greater uncertainty in the location.

### IConstructPoint.ConstructAlong Method

Constructs a point distance units along the input curve.

``````Public Sub ConstructAlong ( _
ByVal curve As ICurve, _
ByVal extension As esriSegmentExtension, _
ByVal distance As Double, _
ByVal asRatio As Boolean _
)
``````
``````public void ConstructAlong (
ICurve curve,
esriSegmentExtension extension,
double distance,
bool asRatio
);
``````

#### Remarks

If the Distance parameter is less than zero, or greater than the length of the curve (when asRatio is false), or greater than one (when asRatio is true), then the value of the Extension parameter is used to determine the coordinates of the constructed point. In these cases, the point can be placed somewhere along an embedding geometry, or somewhere along a tangent geometry.

The embedding geometry of a straight line segment is a straight line extending infinitely in both directions. The embedding geometry of a circular arc is a complete circle. The embedding geometry of an elliptic arc is a complete ellipse. A bezier curve has no embedding geometry.

A tangent geometry is always a ray (a straight line extending infinitely in one direction) tangent to the input curve at either its from (start) or to (end) points.

Possible values for the Extension parameter are: -------------------------------------------------esriNoExtension The constructed point will always be on the input curve. A distance < 0 will pin the constructed point to the location of the input curve's from point. A distance > the curve length (or > 1 when asRatio is true) will pin the location to the curve's to point.

esriExtendTangentAtFrom If the distance parameter is < 0 then the point is constructed along a ray tangent to the start point of the curve, in a direction away from the curve.

esriExtendTangentAtTo If the distance parameter is greater than the length of the input curve (or > 1 when asRatio is true), then the constructed point is placed along a ray tangent to the end point of the curve, in a direction away from the curve.

esriExtendEmbeddedAtFrom Similar to the tangent option, but uses the embedding geometry instead of the tangent lines.

esriExtendEmbeddedAtTo Similar to the tangent option, but uses the embedding geometry instead of the tangent lines.

esriExtendEmbedded The point is constructed based on either the start or end points of the curve.

esriExtendTangents The point is tangential extended from the start or endpoint of the curve.

These values can be combined using the VB Or operator, or the C++ bitwise OR operator.

Example 1: `esriExtendTangentAtFrom Or esriExtendTangentAtTo`

Instead of using `esriExtendTangents` you could use `esriExtendTangentAtFrom Or esriExtendTangentAtTo.`This would allow the point to be constructed anywhere along infinte straight lines, beginning from either the start or end of the curve, regardless of whether the distance parameter was less than 0, or greater than the length of the input curve (or > 1 when asRatio is true). ``````//Select a polyline in ArcMap and calculate a point along the line

// at 100 distance units from the start point.

public void ConstructPointAlongLine(IPolyline pl)

{

ICurve polyLine = pl;

IPoint point1 = ConstructPointAlong(100, polyLine, esriSegmentExtension.esriNoExtension, false);

System.Windows.Forms.MessageBox.Show("x,y = " + point1.X + "," + point1.Y);

IPoint point2 = ConstructPointAlong(0.5, polyLine, esriSegmentExtension.esriNoExtension, true);

System.Windows.Forms.MessageBox.Show("x,y = " + point2.X + "," + point2.Y);

}

public IPoint ConstructPointAlong(double distance, ICurve curve, esriSegmentExtension extension, bool asRatio)

{

IConstructPoint contructionPoint = new PointClass();

contructionPoint.ConstructAlong(curve, extension, distance, asRatio);

return contructionPoint as IPoint;

}
``````
``````'+++ Calculate a point along a polyline

'+++ at 100 distance units from the start point.

Public Sub t_ConstructAlong(ByRef pPolyLine As ESRI.ArcGIS.Geometry.IPolyline)

On Error GoTo Errorhandler

Dim pPoint As ESRI.ArcGIS.Geometry.IPoint

Dim pCrv As ESRI.ArcGIS.Geometry.ICurve

pCrv = pPolyLine

pPoint = PtConstructAlong(100, pCrv, ESRI.ArcGIS.Geometry.esriSegmentExtension.esriNoExtension, False)

MsgBox("x,y = " & pPoint.X & "," & pPoint.Y)

pPoint = PtConstructAlong(0.5, pPolyLine, ESRI.ArcGIS.Geometry.esriSegmentExtension.esriNoExtension, True) ' Midpoint

MsgBox("x,y = " & pPoint.X & "," & pPoint.Y)

Exit Sub

Errorhandler:

MsgBox(Err.Number & "..." & Err.Description)

Exit Sub

End Sub

Public Function PtConstructAlong(ByVal dDist As Double, ByVal pCurve As ESRI.ArcGIS.Geometry.ICurve, ByVal extension As ESRI.ArcGIS.Geometry.esriSegmentExtension, ByVal asRatio As Boolean) As ESRI.ArcGIS.Geometry.IPoint

Dim pCPoint As ESRI.ArcGIS.Geometry.IConstructPoint

pCPoint = New ESRI.ArcGIS.Geometry.Point

pCPoint.ConstructAlong(pCurve, extension, dDist, asRatio)

PtConstructAlong = pCPoint

End Function
``````

### IConstructPoint.ConstructAngleBisector Method

Constructs a point on the bisector of the angle (from, through, to). When useAcuteAngle is false, the sign of distance will select a point right or left of (from, through, to). Otherwise, the sign of distance will select the acute/obtuse point.

``````Public Sub ConstructAngleBisector ( _
ByVal from As IPoint, _
ByVal through As IPoint, _
ByVal to As IPoint, _
ByVal distance As Double, _
ByVal useAcuteAngle As Boolean _
)
``````
``````public void ConstructAngleBisector (
IPoint from,
IPoint through,
IPoint to,
double distance,
bool useAcuteAngle
);
``````

#### Description

Constructs a Point at specified Distance along the line which bisects the Angle formed by the right side of the three input points. If the right side angle is smaller, the constructed line along which the Point is constructed will always bisect this angle, regardless of the value of bUseSmallerAngle. However, if the right side angle is larger, and bUseSmallerAngle is TRUE, then the Point will be on the line constructed which bisects the smaller angle (left side) instead of the right side angle.

#### Remarks

The method uses a vector geometry to calculate the point. The Smaller Angle is the angle less than PI.If From , To and Through points are all on a straight line , the point is calculated perpendicular (to the right) of the line. ``````private void ConstructAngleBisector()

{

IPoint fromPoint = new PointClass();

fromPoint.PutCoords(0, 0);

IPoint throughPoint = new PointClass();

throughPoint.PutCoords(10, 0);

IPoint toPoint = new PointClass();

toPoint.PutCoords(0, 10);

IConstructPoint constructionPoint = new PointClass();

constructionPoint.ConstructAngleBisector(fromPoint, throughPoint, toPoint, 10, true);

IPoint outPutPoint = constructionPoint as IPoint;

System.Windows.Forms.MessageBox.Show("Output point : " + outPutPoint.X + " , " + outPutPoint.Y);

}
``````
``````Public Sub ConstructAngleBisector()

Dim ptTr As ESRI.ArcGIS.Geometry.IPoint

Dim ptTo As ESRI.ArcGIS.Geometry.IPoint

Dim ptFrom As ESRI.ArcGIS.Geometry.IPoint

Dim pConstructLine As ESRI.ArcGIS.Geometry.IConstructLine

Dim pOutPutLine As ESRI.ArcGIS.Geometry.ILine

Dim Pi As Double

Pi = 4 * Math.Atan(1)

ptTr = New ESRI.ArcGIS.Geometry.Point

ptTo = New ESRI.ArcGIS.Geometry.Point

ptFrom = New ESRI.ArcGIS.Geometry.Point

pConstructLine = New ESRI.ArcGIS.Geometry.Line

ptTr.PutCoords(0, 0)

ptTo.PutCoords(0, 10)

ptFrom.PutCoords(10, 0)

pConstructLine.ConstructAngleBisector(ptFrom, ptTr, ptTo, 10, True)

pOutPutLine = pConstructLine 'QI

Debug.Print(pOutPutLine.Length)

'Angle from the XAxis

Debug.Print((180 * pOutPutLine.Angle) / Pi)

End Sub
``````

### IConstructPoint.ConstructAngleDistance Method

Constructs a point at a specified angle (in radians) from the horizontal axis and a specified distance away from the input point.

``````Public Sub ConstructAngleDistance ( _
ByVal p As IPoint, _
ByVal inAngle As Double, _
ByVal distance As Double _
)
``````
``````public void ConstructAngleDistance (
IPoint p,
double inAngle,
double distance
);
``````

#### Description

The ConstructAngleDistance method, given a point (p), construct another point at an angle (inangle) and a distance(distance).

#### Remarks

Angle in radians and distancein map units. The angle is measured counter-clockwise from the horizontal line and can be negative. If the distance is negative then the opposite direction is assumed (same as angle + PI). ``````// select a point in ArcMap and calculate a new point with the

// angle of 45 degrees and distance on 250 map units.

public void ConstructAngleDistance()

{

IMxDocument mxDocument = m_application.Document as IMxDocument;

IMap map = mxDocument.FocusMap;

ISelection featureSelection = map.FeatureSelection;

IEnumFeature featureEnumerator = featureSelection as IEnumFeature;

featureEnumerator.Reset();

IFeature currentFeature = featureEnumerator.Next();

double distance = 250;

double angle = 45;

while (currentFeature != null)

{

if (currentFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)

{

IPoint startPoint = currentFeature.Shape as IPoint;

System.Windows.Forms.MessageBox.Show("Start Point: " + startPoint.X + ", " + startPoint.Y + "\n" +

"Angle: " + angle + "\n" + "Distance: " + distance);

IPoint point = _ConstructAngleDistance(startPoint, angle, distance);

System.Windows.Forms.MessageBox.Show("x,y = " + point.X + "," + point.Y);

}

currentFeature = featureEnumerator.Next();

}

}

private IPoint _ConstructAngleDistance(IPoint point, double angle, double distance)

{

//Convert the angle degrees to radians

double angleRad = angle * 2 * Math.PI / 360;

IConstructPoint construcionPoint = new PointClass();

return construcionPoint as IPoint;

}
``````
``````'+++ select a point in ArcMap and calculate a new point with the

'+++ angle of 45 degrees and distance on 100 map units.

Public Sub t_ConstructAngleDistance(ByRef pMXDoc As ESRI.ArcGIS.ArcMapUI.IMxDocument)

On Error GoTo Errorhandler

Dim pEnumFeat As ESRI.ArcGIS.Geodatabase.IEnumFeature

Dim pFeature As ESRI.ArcGIS.Geodatabase.IFeature

Dim pSelection As ESRI.ArcGIS.Carto.ISelection

Dim pMap As ESRI.ArcGIS.Carto.IMap

Dim pPoint As ESRI.ArcGIS.Geometry.IPoint

Dim pStart As ESRI.ArcGIS.Geometry.IPoint

Dim dDist As Long

Dim dAngle As Long

pMap = pMXDoc.FocusMap

pSelection = pMap.FeatureSelection

pEnumFeat = pSelection

pEnumFeat.Reset()

pFeature = pEnumFeat.Next

dDist = 250

dAngle = 45

While Not pFeature Is Nothing

If pFeature.Shape.GeometryType = ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint Then

pStart = pFeature.Shape

Debug.Print(1, "Start Point:" & pStart.X & "," & pStart.Y & vbCrLf & _

"Angle:" & dAngle & vbCrLf & "Distance:" & dDist)

pPoint = PtConstructAngleDistance(pStart, dAngle, dDist)

Debug.Print(1, "x,y = " & pPoint.X & "," & pPoint.Y & vbCrLf)

End If

pFeature = pEnumFeat.Next

End While

Exit Sub

Errorhandler:

MsgBox(Err.Number & "..." & Err.Description)

Exit Sub

End Sub

Public Function PtConstructAngleDistance(ByVal pPoint As ESRI.ArcGIS.Geometry.IPoint, ByVal dAngle As Long, ByVal dDist As Long) As ESRI.ArcGIS.Geometry.IPoint

Const PI = 3.14159265358979

Dim pCPoint As ESRI.ArcGIS.Geometry.IConstructPoint

pCPoint = New ESRI.ArcGIS.Geometry.Point

dAngleRad = dAngle * 2 * PI / 360 'Convert the angle degrees to radians

PtConstructAngleDistance = pCPoint

End Function
``````

### IConstructPoint.ConstructAngleIntersection Method

Constructs the point of intersection between two lines defined by the input points and angles (in radians).

``````Public Sub ConstructAngleIntersection ( _
ByVal p1 As IPoint, _
ByVal angle1 As Double, _
ByVal p2 As IPoint, _
ByVal angle2 As Double _
)
``````
``````public void ConstructAngleIntersection (
IPoint p1,
double angle1,
IPoint p2,
double angle2
);
``````

#### Remarks

Angles are specified as geometric angles measured counterclockwise from the positive x axis of the Cartesian coordinate system. All angles are specified in radians . ``````//This method constructs a new point as intersection of 2 lines

public void ConstructAngleIntersection()

{

IPoint fromPoint = new PointClass();

fromPoint.PutCoords(0, 0);

IPoint toPoint = new PointClass();

toPoint.PutCoords(100, 0);

double angle1Rad = 45 * 2 * Math.PI / 360;

double angle2Rad = 135 * 2 * Math.PI / 360;

IConstructPoint constructionPoint = new PointClass();

IPoint outPutPoint = constructionPoint as IPoint;

System.Windows.Forms.MessageBox.Show("Output point : " + outPutPoint.X + " , " + outPutPoint.Y);

}
``````
``````'+++ Construct a new point as intersection of 2 lines

Public Sub t_ConstructAngleIntersection()

On Error GoTo Errorhandler

Dim pPoint1 As ESRI.ArcGIS.Geometry.IPoint

Dim pPoint2 As ESRI.ArcGIS.Geometry.IPoint

Dim pPoint As ESRI.ArcGIS.Geometry.IPoint

Dim dAngle1 As Long

Dim dAngle2 As Long

pPoint1 = New ESRI.ArcGIS.Geometry.Point

pPoint2 = New ESRI.ArcGIS.Geometry.Point

pPoint1.PutCoords(0, 0)

pPoint2.PutCoords(100, 0)

dAngle1 = 45

dAngle2 = 135

pPoint = ptConstructAngleIntersection(pPoint1, dAngle1, pPoint2, dAngle2)

MsgBox("x,y = " & pPoint.X & "," & pPoint.Y)

Exit Sub

Errorhandler:

MsgBox(Err.Number & "..." & Err.Description)

Exit Sub

End Sub

Public Function ptConstructAngleIntersection(ByVal pPt1 As ESRI.ArcGIS.Geometry.IPoint, ByVal dAngle1 As Long, ByVal pPt2 As ESRI.ArcGIS.Geometry.IPoint, ByVal dAngle2 As Long) As ESRI.ArcGIS.Geometry.IPoint

Const PI As Double = 3.14159265358979

Dim pCPoint As ESRI.ArcGIS.Geometry.IConstructPoint

pCPoint = New ESRI.ArcGIS.Geometry.Point

dAngleRad1 = dAngle1 * 2 * PI / 360 ' Conversion degrees to radians

dAngleRad2 = dAngle2 * 2 * PI / 360

ptConstructAngleIntersection = pCPoint

End Function
``````

### IConstructPoint.ConstructDeflection Method

Constructs a point in the polar coordinate system defined by baseLine and its 'from' point. The angle is in radians.

``````Public Sub ConstructDeflection ( _
ByVal baseLine As ILine, _
ByVal distance As Double, _
ByVal inAngle As Double _
)
``````
``````public void ConstructDeflection (
ILine baseLine,
double distance,
double inAngle
);
``````

#### Description

The ConstructDeflection method, given a line (baseline), creates a new point at a distance (distance) and at an angle (inAngle).

#### Remarks

The point is constructed from the baseline start point using the deflection angle (the angle from the baseline to the point) and the distance. The deflection angle is given in radians the distance in map units. When distance is > 0, a positive value for angle rotates the constructed point counter-clockwise about the start point of baseline, and a negative value for angle rotates it the other way. Vice versa when distance is < 0. ``````//Constructs a point from the baseline from (0,0) to (1,1)

// with the deflection angle of 45 degrees (PI/4 radians).

public void ConstructDeflection()

{

IPoint fromPoint = new PointClass();

fromPoint.PutCoords(0, 0);

IPoint toPoint = new PointClass();

toPoint.PutCoords(1, 1);

ILine line = new LineClass();

line.PutCoords(fromPoint, toPoint);

double distance = 1.4142135623731;

double angle = Math.PI / 4;

IConstructPoint constructionPoint = new PointClass();

constructionPoint.ConstructDeflection(line, distance, angle);

IPoint point = constructionPoint as IPoint;

System.Windows.Forms.MessageBox.Show("x,y = " + point.X + ", " + point.Y);

}
``````
``````'+++ Constructs a point from the baseline from (0,0) to (1,1)

'+++ with the deflection angle of 45 degrees (PI/4 radians).

Public Sub t_ConstructDeflection()

On Error GoTo Errorhandler

Dim pPointFrom As IPoint

Dim pPointTo As IPoint

Dim pLine As ILine

Dim pPoint As IPoint

Dim pCPoint As IConstructPoint

Dim dDist As Double

Dim dAngle As Double

Dim pi As Double

pPointFrom = New Point

pPointTo = New Point

pCPoint = New Point

pPoint = New Point

pLine = New Line

pPointFrom.PutCoords(0, 0)

pPointTo.PutCoords(1, 1)

pLine.PutCoords(pPointFrom, pPointTo)

dDist = 1.4142135623731

pi = 4 * Math.Atan(1)

dAngle = pi / 4

pCPoint.ConstructDeflection(pLine, dDist, dAngle)

pPoint = pCPoint

MsgBox("x,y = " & pPoint.X & "," & pPoint.Y)

Exit Sub

Errorhandler:

MsgBox(Err.Number & "..." & Err.Description)

Exit Sub

End Sub
``````

### IConstructPoint.ConstructDeflectionIntersection Method

Constructs the point of intersection of two rays with origins at the endpoints of the base line and the specified angles (in radians). If onRightSide is true, this work will be done to the right of the base line, otherwise to the left.

``````Public Sub ConstructDeflectionIntersection ( _
ByVal baseLine As ILine, _
ByVal startAngle As Double, _
ByVal endAngle As Double, _
ByVal OnRightSide As Boolean _
)
``````
``````public void ConstructDeflectionIntersection (
ILine baseLine,
double startAngle,
double endAngle,
bool OnRightSide
);
``````

#### Remarks

the bRightSide flag can be used to always force the constructed point to be on the right side of the baseline.The startAngle is the angle (in radians) from the baseline's startpoint of the line to the constructed point. The endAngle is the angle (in radians) from the baseline's endpoint to the constructed point.Both angles have to be > 0 and < 2 PI radians. Their sum must also be less than PI radians. ``````//Constructs a point from the baseline from (0,0) to (1,1)

//with the deflection angle of 45 degrees (PI/4 radians).

public void ConstructDeflectionIntersection()

{

IPoint fromPoint = new PointClass();

fromPoint.PutCoords(0, 0);

IPoint toPoint = new PointClass();

toPoint.PutCoords(1, 1);

ILine line = new LineClass();

line.PutCoords(fromPoint, toPoint);

double startAngle = Math.PI / 4;

double endAngle = Math.PI / 4;

IConstructPoint constructionPoint = new PointClass();

constructionPoint.ConstructDeflectionIntersection(line, startAngle, endAngle, false);

IPoint point = constructionPoint as IPoint;

System.Windows.Forms.MessageBox.Show("x,y = " + point.X + ", " + point.Y);

}
``````
``````'+++ Constructs a point as the intersection of 2 lines with angles

'+++ dStartAngle (from the startpoint of the line) and dEndAngle.

'+++ The flag to force the line to the right side is turned off.

Public Sub t_ConstructDeflectionIntersection()

Dim pPointFrom As ESRI.ArcGIS.Geometry.IPoint

Dim pPointTo As ESRI.ArcGIS.Geometry.IPoint

Dim pLine As ESRI.ArcGIS.Geometry.ILine

Dim pPoint As ESRI.ArcGIS.Geometry.IPoint

Dim pCPoint As ESRI.ArcGIS.Geometry.IConstructPoint

Dim dStartAngle As Double

Dim dEndAngle As Double

Dim pi As Double

pPointFrom = New ESRI.ArcGIS.Geometry.Point

pPointTo = New ESRI.ArcGIS.Geometry.Point

pCPoint = New ESRI.ArcGIS.Geometry.Point

pPoint = New ESRI.ArcGIS.Geometry.Point

pLine = New ESRI.ArcGIS.Geometry.Line

pPointFrom.PutCoords(0, 0)

pPointTo.PutCoords(1, 0)

pLine.PutCoords(pPointFrom, pPointTo)

pi = 4 * Math.Atan(1)

dStartAngle = pi / 4

dEndAngle = pi / 4

pCPoint.ConstructDeflectionIntersection(pLine, dStartAngle, dEndAngle, False)

pPoint = pCPoint

MsgBox("x,y = " & pPoint.X & "," & pPoint.Y)

End Sub
``````

### IConstructPoint.ConstructOffset Method

Constructs a point distance units along the input curve and offset units perpendicularly away from it.

``````Public Sub ConstructOffset ( _
ByVal curve As ICurve, _
ByVal extension As esriSegmentExtension, _
ByVal distance As Double, _
ByVal asRatio As Boolean, _
ByVal Offset As Double _
)
``````
``````public void ConstructOffset (
ICurve curve,
esriSegmentExtension extension,
double distance,
bool asRatio,
double Offset
);
``````

#### Remarks

A positive Offset distance will create a point on the right side of the curve and a negative offset will create a point on the left side of the curve. Set the asRatio flag to be True if you want the distance to be a ratio of the curve length. If set to True, then a distance of 0.5 will be equal to half of the curve length (i.e. 50%).

``````//This example demonstrates how to use IConstructPoint.ConstructOffset method

private void ConstructOffset()

{

IPoint[] points = new IPoint;

for (int i = 0; i < 4; i++)

{

points[i] = new PointClass();

}

points.PutCoords(0, 0);

points.PutCoords(10, 0);

points.PutCoords(20, 0);

points.PutCoords(30, 0);

IPointCollection polyline = new Polyline();

//helper class to solve C-Style Array usage in COM classes

IGeometryBridge geometryBride = new GeometryEnvironmentClass();

IConstructPoint constructionPoint = new PointClass();

//The spatial reference should be set on the new point here (Code skipped)

//Example 1: Distance No ratio, Positive offset

constructionPoint.ConstructOffset(polyline as ICurve, esriSegmentExtension.esriNoExtension, 15, false, 5);

IPoint outPutPoint1 = constructionPoint as IPoint;

System.Windows.Forms.MessageBox.Show("Output point : " + outPutPoint1.X + " , " + outPutPoint1.Y);

//Output point : 15 , -5

//*********************************************

//Example 2: Distance as ratio, Positive offset

constructionPoint.ConstructOffset(polyline as ICurve, esriSegmentExtension.esriNoExtension, 0.5, true, 5);

IPoint outPutPoint2 = constructionPoint as IPoint;

System.Windows.Forms.MessageBox.Show("Output point : " + outPutPoint2.X + " , " + outPutPoint2.Y);

//Output point : 15 , -5

//*********************************************

//Example 3: Distance No ratio, Negative offset

constructionPoint.ConstructOffset(polyline as ICurve, esriSegmentExtension.esriNoExtension, 15, false, -5);

IPoint outPutPoint3 = constructionPoint as IPoint;

System.Windows.Forms.MessageBox.Show("Output point : " + outPutPoint3.X + " , " + outPutPoint3.Y);

//Output point : 15 , 5

}
``````
``````'This example demonstrates how to use IConstructPoint::ConstructOffset

Sub ConstructOffset()

Dim ptc As IPointCollection, pt(3) As IPoint, i As Long

Dim pconsPoint As IConstructPoint, ptout As IPoint

ptc = New Polyline

'The spatial reference should be set on the polyline here (Code skipped)

For i = 0 To 3

pt(i) = New Point

Next

pt(0).PutCoords(0, 0)

pt(1).PutCoords(10, 0)

pt(2).PutCoords(20, 0)

pt(3).PutCoords(30, 0)

'The spatial reference should be set on the new point here (Code skipped)

'*********************************************

'Example 1: Distance No ratio, Positive offset

pconsPoint = New Point

pconsPoint.ConstructOffset(ptc, esriSegmentExtension.esriNoExtension, 15, False, 5)

ptout = pconsPoint

Debug.Print("Output point : " & ptout.X & " , " & ptout.Y)

'Output point : 15 , -5

'*********************************************

'Example 2: Distance as ratio, Positive offset

pconsPoint = New Point

pconsPoint.ConstructOffset(ptc, esriSegmentExtension.esriNoExtension, 0.5, True, 5)

ptout = pconsPoint

Debug.Print("Output point : " & ptout.X & " , " & ptout.Y)

'Output point : 15 , -5

'*********************************************

'Example 3: Distance No ratio, Negative offset

pconsPoint = New Point

pconsPoint.ConstructOffset(ptc, esriSegmentExtension.esriNoExtension, 15, False, -5)

ptout = pconsPoint

Debug.Print("Output point : " & ptout.X & " , " & ptout.Y)

'Output point : 15 , 5

End Sub
``````

### IConstructPoint.ConstructParallel Method

Constructs a point distance units from start, parallel to the tangent at the point nearest to start on the (extended) segment.

``````Public Sub ConstructParallel ( _
ByVal Segment As ISegment, _
ByVal extension As esriSegmentExtension, _
ByVal start As IPoint, _
ByVal distance As Double _
)
``````
``````public void ConstructParallel (
ISegment Segment,
esriSegmentExtension extension,
IPoint start,
double distance
);
``````

#### Description

ConstructParallel constructs a Point a specified distance from the input point in the direction parallel to the tangent of the nearest point on the extended input segment.

#### Remarks ``````//The example shows how to construct a point parallel to the first segment

//of a selected polyline. Use ArcMap and the Object Editor to select the

//polyline.

public void ConstructPointParallelToLine(IMxDocument mxDocument)

{

IMap map = mxDocument.FocusMap;

IEnumFeature selectedFeatures = map.FeatureSelection as IEnumFeature;

selectedFeatures.Reset();

IFeature currentFeature = selectedFeatures.Next();

IConstructPoint constructionPoint = new PointClass();

while (currentFeature != null)

{

if (currentFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)

{

IGeometryCollection geometryCollection = currentFeature.Shape as IGeometryCollection;

ISegmentCollection segmentCollection = geometryCollection.get_Geometry(0) as ISegmentCollection;

ISegment segment = segmentCollection.get_Segment(0);

IPoint fromPoint = new PointClass();

segment.QueryFromPoint(fromPoint);

//add 10 to the x coordinate in order to get a diffrent point for this example

fromPoint.X = fromPoint.X + 10;

constructionPoint.ConstructParallel(segment, esriSegmentExtension.esriNoExtension, fromPoint, segment.Length / 2);

IPoint outPutPoint = constructionPoint as IPoint;

System.Windows.Forms.MessageBox.Show("Output point : " + outPutPoint.X + " , " + outPutPoint.Y);

}

currentFeature = selectedFeatures.Next();

}

}
``````
``````' The example shows how to construct a point parallel to the first segment

' of a selected polyline. Use ArcMap and the Object Editor to select the

' polyline.

Public Sub t_constructParallel(ByVal pApp As ESRI.ArcGIS.Framework.IApplication)

Dim pID As New ESRI.ArcGIS.esriSystem.UID

pID = "esriEditor.editor"

Dim pEditor As ESRI.ArcGIS.Editor.IEditor

pEditor = pApp.FindExtensionByCLSID(pID)

If pEditor.SelectionCount > 1 Then

MsgBox("select one polyline")

Exit Sub

End If

Dim pEnumFeat As ESRI.ArcGIS.Geodatabase.IEnumFeature

Dim pFeature As ESRI.ArcGIS.Geodatabase.IFeature

Dim i As Long

pEnumFeat = pEditor.EditSelection

Dim pSeg As ESRI.ArcGIS.Geometry.ISegment

Dim pGeoColl As ESRI.ArcGIS.Geometry.IGeometryCollection

Dim pPoint As ESRI.ArcGIS.Geometry.IPoint

pPoint = New ESRI.ArcGIS.Geometry.Point

Dim pCPoint As ESRI.ArcGIS.Geometry.IConstructPoint

pCPoint = New ESRI.ArcGIS.Geometry.Point

Dim pThroughPoint As ESRI.ArcGIS.Geometry.IPoint

pThroughPoint = New ESRI.ArcGIS.Geometry.Point

pFeature = pEnumFeat.Next

While Not pFeature Is Nothing

If pFeature.Shape.GeometryType = ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline Then

pGeoColl = pFeature.Shape

Dim pSegColl As ESRI.ArcGIS.Geometry.ISegmentCollection

pSegColl = pGeoColl.Geometry(0)

pSeg = pSegColl.Segment(0)

pSeg.QueryFromPoint(pThroughPoint)

pThroughPoint.X = pThroughPoint.X + 10

pCPoint.ConstructParallel(pSeg, ESRI.ArcGIS.Geometry.esriSegmentExtension.esriNoExtension, pThroughPoint, pSeg.Length / 2)

pPoint = pCPoint

MsgBox(pPoint.X & "," & pPoint.Y)

End If

pFeature = pEnumFeat.Next

End While

End Sub
``````

### IConstructPoint.ConstructPerpendicular Method

Constructs a point 'distance' units from p and lying along the line normal to base and passing through p.

``````Public Sub ConstructPerpendicular ( _
ByVal base As ISegment, _
ByVal extension As esriSegmentExtension, _
ByVal p As IPoint, _
ByVal distance As Double, _
ByVal bUseLineOrientation As Boolean _
)
``````
``````public void ConstructPerpendicular (
ISegment base,
esriSegmentExtension extension,
IPoint p,
double distance,
bool bUseLineOrientation
);
``````

#### Description

ConstructPerpendicular constructs a Point a specified distance from the input point in the direction parallel to the normal (perpendicular to the tangent) of the nearest point on the extended input segment.

#### Remarks ### IConstructPoint.ConstructThreePointResection Method

Constructs the point of observation from which two signed angles between three points were measured; returns an angle which can help establish the confidence of the observation location: A small angle indicates greater uncertainty in the location.

``````Public Sub ConstructThreePointResection ( _
ByVal point1 As IPoint, _
ByVal angleP1P2 As Double, _
ByVal point2 As IPoint, _
ByVal angleP2P3 As Double, _
ByVal point3 As IPoint, _
ByRef arcAngle As Double _
)
``````
``````public void ConstructThreePointResection (
IPoint point1,
double angleP1P2,
IPoint point2,
double angleP2P3,
IPoint point3,
ref double arcAngle
);
``````

#### Description

The ConstructThreePointResection method constructs a new point given three points and two signed view angles. It finds the viewpoints from which the two point pairs are viewed at the given angles. When both angles are equal to pi/2 radians, there is only one solution; otherwise there can be up to four solutions. A positive angle indicates that the viewpoint is to be on the right hand side of the line between the corresponding points; a negative angle places the resulting point on the left. There may not be a feasible solution for the given input, in which case the resulting point is empty. The quality of the solution is given by the arcAngle parameter. The smaller the angle the less stable the solution. The returned angle is between 0 and pi/2.

#### Remarks

Given three points and two angles measured from the constructed point. Note that there is no unique solution if all three points are on the same circle.

``````Private Shared Sub t_ConstructThreePointResection()

On Error GoTo Errorhandler

Dim pPoint As IPoint

Dim pCPoint As IConstructPoint

Dim pPoint1 As IPoint

Dim pPoint2 As IPoint

Dim pPoint3 As IPoint

Dim dAngle1 As Double

Dim dAngle2 As Double

pCPoint = New Point

pPoint = New Point

pPoint1 = New Point

pPoint2 = New Point

pPoint3 = New Point

pPoint1.PutCoords(0, 1)

pPoint2.PutCoords(2, 2)

pPoint3.PutCoords(1, 0)

dAngle1 = Math.PI / 4

dAngle2 = Math.PI / 4

pCPoint.ConstructThreePointResection(pPoint1, dAngle1, pPoint2, dAngle2, pPoint3, Math.PI / 2)

pPoint = pCPoint

MsgBox("x,y = " & pPoint.X & "," & pPoint.Y)

Exit Sub

Errorhandler:

MsgBox(Err.Number & "..." & Err.Description)

Exit Sub

End Sub
``````

## Classes that implement IConstructPoint

Classes Description
Point A two dimensional point, optionally with measure, height, and ID attributes.