Coordinate geometry and areas

Once control points have coordinates, almost every surveying task becomes a coordinate geometry problem. Where should a stake go so that it lies on the property line 18 m from the corner? What is the distance and azimuth between two monuments that cannot see each other? Where do two lines intersect? What is the area of a lot? Coordinate geometry, usually shortened to COGO, answers these questions with simple trigonometry applied to northings and eastings. It is built into every data collector and design program, but surveyors and engineers must understand it well enough to check results and to solve problems when the software is not at hand. This lesson covers the inverse and forward computations, radiation surveys, intersections, offsets and areas by coordinates, using the Coulee Ridge traverse coordinates from lesson 7.

Coordinates and conventions

Surveying coordinates are written as northing and easting, usually in that order, with north as the reference direction for azimuths. This is different from the mathematical convention of x and y with angles measured counterclockwise from the x axis. In surveying, the easting plays the role of x and the northing the role of y, and azimuths run clockwise from north. As a result, the trigonometry swaps sine and cosine compared with the mathematical form: the change in northing uses the cosine of the azimuth and the change in easting uses the sine. Mixing the two conventions is a common source of errors in spreadsheets and programs.

The forward computation

Given the coordinates of a known point, and the azimuth and horizontal distance to a new point, the new point's coordinates follow directly:

This is exactly how a total station's data collector computes coordinates during a topographic survey. From a setup on a known point, oriented on a backsight, every observation of horizontal angle and distance becomes an azimuth and distance, and every target becomes a coordinated point. Collecting points this way is called a radiation survey or side shots, because the lines radiate from the instrument. Each radiated point is measured once and has no check, so important points are measured from two setups or tied by a second measurement.

The inverse computation

The inverse computation works the other way: given two points with coordinates, find the azimuth and horizontal distance between them. It is used constantly, for example to compute the backsight azimuth when setting up a total station, to find the length of a property line, or to check that a set stake is where it should be.

The arctangent gives an angle between −90° and +90°, so the quadrant must be determined from the signs of ΔN and ΔE. Programming languages provide a two-argument arctangent, often called atan2, which handles the quadrant automatically; in surveying it is used as atan2(ΔE, ΔN), with easting first, so that the result is an azimuth from north. A negative result is converted to the 0° to 360° range by adding 360°.

Intersections

Many layout and boundary problems require the point where two lines meet. Three cases are common.

• Bearing–bearing (azimuth–azimuth) intersection: two lines, each defined by a known point and an azimuth, meet at a point. This occurs, for example, when locating the corner where two property lines meet, or a point sighted from two control stations.
• Distance–distance intersection: two circles, each centered on a known point with a known radius, meet at up to two points. This is used to locate a point from two measured distances, such as a tie from two building corners.
• Azimuth–distance intersection: a line from one point meets a circle around another, giving up to two solutions.

For an azimuth–azimuth intersection, the unknown point P lies at distance \(t\) from point A along azimuth \(\alpha\) and at distance \(u\) from point B along azimuth \(\beta\). Writing both expressions for P and equating them gives two linear equations in \(t\) and \(u\). A convenient solution uses the triangle formed by A, B and P: the inverse from A to B gives the length and azimuth of AB, the angles at A and B follow from the azimuth differences, and the sine law gives the other two sides.

Offsets from a line

Layout and boundary work often need the perpendicular offset from a point to a line and the distance along the line to the foot of the perpendicular. If a line runs from A on azimuth \(\alpha\), and a point P is at distance \(d\) and azimuth \(\theta\) from A (from an inverse), then the distance along the line and the offset are:

A positive offset is to the right of the line looking from A in the direction \(\alpha\), and a negative offset is to the left. This is the computation behind checking whether a building is set back far enough from a property line, or how far an as-built pipe is from its design alignment.

Areas by coordinates

The area of any closed polygon whose corners have coordinates can be computed by the coordinate method, sometimes called the shoelace formula after the criss-cross pattern of its products. List the corners in order around the polygon, repeat the first at the end, and compute:

The sign of the sum depends on whether the corners are listed clockwise or counterclockwise, so the absolute value is taken. The method works for concave polygons as long as the boundary does not cross itself. To avoid rounding problems with large coordinate values, it is common to subtract a constant from all northings and eastings before computing, which does not change the area. An equivalent older method computes the area from latitudes and departures using double meridian distances, and it appears in many older textbooks and plans.

# COGO toolkit: inverse, forward, azimuth-azimuth intersection, offsets and area
import math

def inverse(p, q):
    dN, dE = q[0] - p[0], q[1] - p[1]
    return math.hypot(dN, dE), math.degrees(math.atan2(dE, dN)) % 360

def forward(p, az, L):
    a = math.radians(az)
    return p[0] + L * math.cos(a), p[1] + L * math.sin(a)

def intersect(A, azA, B, azB):
    a, b = math.radians(azA), math.radians(azB)
    dN, dE = B[0] - A[0], B[1] - A[1]
    det = math.cos(a) * -math.sin(b) + math.cos(b) * math.sin(a)
    t = (dN * -math.sin(b) + math.cos(b) * dE) / det
    return forward(A, azA, t)

def offset(A, az_line, P):
    d, th = inverse(A, P)
    r = math.radians(th - az_line)
    return d * math.cos(r), d * math.sin(r)

def area(pts):
    n = len(pts)
    return abs(sum(pts[i][1] * pts[(i + 1) % n][0] - pts[(i + 1) % n][1] * pts[i][0] for i in range(n))) / 2

CR5, CR6, CR7, CR8 = (4688.897, 1206.750), (4715.349, 1704.535), (5072.682, 1782.222), (5193.424, 1367.899)
L, az = inverse(CR6, CR8)
print(f"CR-6 to CR-8: {L:.3f} m at {az:.4f} deg")
print("shed corner:", tuple(round(x, 3) for x in forward(CR5, 41 + 12/60 + 20/3600, 156.338)))
P = intersect(CR6, 330.25, CR7, 245 + 40/60)
print("fence corner:", tuple(round(x, 3) for x in P))
along, off = offset(CR6, inverse(CR6, CR7)[1], P)
print(f"fence corner is {along:.3f} m along CR-6 to CR-7 and {off:.3f} m off the line (negative = left)")

lot = [(4812.315, 1405.220), (4815.102, 1423.987), (4851.006, 1419.441), (4849.770, 1398.512)]
loop = [(5000.000, 1000.000), CR5, CR6, CR7, CR8]
print(f"lot area {area(lot):.2f} m2; traverse area {area(loop):,.1f} m2 = {area(loop) / 10000:.3f} ha = {area(loop) / 4046.8564224:.2f} acres")

CR-6 to CR-8: 584.705 m at 324.8487 deg
shed corner: (4806.518, 1309.74)
fence corner: (4971.377, 1558.203)
fence corner is 219.096 m along CR-6 to CR-7 and -197.383 m off the line (negative = left)
lot area 739.33 m2; traverse area 279,379.8 m2 = 27.938 ha = 69.04 acres

The coordinates of the Coulee Ridge traverse itself enclose 279,379.8 m², or 27.938 ha (about 69.04 acres), which Ruth compares with the area of the subdivision boundary on the title records as a rough check on the overall survey.

Precision of computed areas

Areas inherit the errors of the coordinates. For a parcel whose corners are each known to a few millimeters, the area of a typical lot is uncertain by a fraction of a square meter, as the error propagation example in lesson 2 showed. Legal plans therefore report areas to a sensible precision, such as 0.01 m² or 0.001 ha in Canada, or 0.01 acre or the nearest square foot in the United States, depending on the size of the parcel and the applicable standards. More digits do not make an area more accurate.

Subdivision problems

A common design problem is to cut a parcel into lots of specified area or frontage. For example, a line parallel to one side may need to be placed so that it cuts off exactly 800 m². Such problems are solved by computing the area of a trial shape, finding how the area changes as the dividing line moves, and adjusting, or by solving the geometry directly for simple shapes such as trapezoids. Design software does this iteratively, but the logic is the same: every lot corner ends up with coordinates, and the plan dimensions, bearings and areas are all computed by the inverse and area routines shown in this lesson. On the ground, those corners are then staked by the forward computation from the nearest control point.

Checking COGO work

Coordinate geometry is precise, but it faithfully propagates any wrong input. Good habits include:

• Sketching every problem roughly to scale, so that a computed azimuth in the wrong quadrant or a distance off by a factor is obvious.
• Checking inverses by recomputing the forward point, and intersections by computing from both known points.
• Verifying that closed figures close: the sum of computed latitudes and departures around a lot should be zero.
• Keeping track of the coordinate system and units of every point list, especially when combining data from different sources.