ForHosting KIT · Engineering & construction

Horizontal curve long chord calculator

A curve with a 300 m radius and a 60-degree deflection has a long chord of exactly 300 m between the start and the end of the curve. You also get tangent length, arc length, middle ordinate and external distance. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Radius: 300
Deflection angle: 60

You get

Deflection angle deg: 60
Deflection angle rad: 1.0471975512
Half deflection deg: 30
Long chord: 300

The long chord of a horizontal circular curve is the straight-line distance from the point of curvature (PC) to the point of tangency (PT) — the full chord that closes the simple curve, not a short deflection chord used while staking intermediate stations. Highway, railway, and municipal alignment design start from a radius R and a total deflection angle Δ, also called the intersection angle I, which equals the central angle at the curve centre. Enter a positive radius and a total deflection strictly between 0 and 180 degrees, or the equivalent in radians.

What the long chord is and how it is found

A simple circular curve joins two straight tangents with a constant radius. The back tangent and forward tangent meet at the point of intersection (PI). The curve leaves the back tangent at the point of curvature (PC) and meets the forward tangent at the point of tangency (PT).

The total deflection angle Δ is the change of direction between those two tangents; by construction it equals the central angle subtended by the arc from PC to PT. Drop perpendiculars from the curve centre to the two radii at PC and PT and you have an isosceles triangle whose equal sides are R and whose vertex angle is Δ.

Surveyors stake the long chord as a check between PC and PT, compare it with a taped or GNSS baseline, and use it to recover the middle ordinate and external distance.

The same two inputs also give T = R tan(Δ/2), the tangent length from PI to PC or PI to PT; L = R times Δ in radians, the arc length along the centreline; M = R (1 − cos(Δ/2)), the middle ordinate from the long-chord midpoint out to the curve; and E = R (sec(Δ/2) − 1), the external distance from the PI in to the midpoint of the curve. All five lengths use the same unit as the radius you send.

What you can do with it

Highway and railway alignment checks

Convert a chosen radius and intersection angle into the long chord from PC to PT, plus T, L, M, and E, before staking or comparing a GNSS baseline.

FAQ

What is the long chord of a circular curve?

The long chord LC is the straight-line distance from the point of curvature (PC) to the point of tangency (PT).

Is the total deflection angle the same as the central angle?

Yes. On a simple circular curve the intersection angle between the two tangents equals the central angle subtended by the arc from PC to PT.

What units should I use for radius and deflection?

Radius is any consistent length unit (metres, feet, …); the long chord comes back in that same unit. Deflection defaults to decimal degrees.

Why is a 180-degree deflection rejected?

A simple-curve deflection must stay strictly between 0 and 180 degrees so tan(Δ/2) and sec(Δ/2) stay finite. A 180-degree turn would put the PI at infinity.

What other curve elements does the calculator return?

Besides the long chord, it gives the tangent length from the intersection point, the arc length along the centreline, the middle ordinate and the external distance. All of them use the same length unit as the radius.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/eng/curve-long-chord

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/eng/curve-long-chord \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"radius":300,"deflection_angle":60}'

const res = await fetch("https://api.kit.forhosting.com/eng/curve-long-chord", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "radius": 300,
    "deflection_angle": 60
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/eng/curve-long-chord",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "radius": 300,
    "deflection_angle": 60
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/eng/curve-long-chord", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"radius":300,"deflection_angle":60}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"radius":300,"deflection_angle":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/eng/curve-long-chord", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "radius": 300,
  "deflection_angle": 60
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "eng.curve_long_chord",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

This horizontal curve long chord calculator applies the textbook identity LC = 2 R sin(Δ/2) and also returns the companion circular-curve elements that share those two inputs: tangent length T, curve length L, middle ordinate M, and external distance E. Invalid input fails with invalid_input and is not billed.

What the long chord is and why LC = 2 R sin(Δ/2)

Bisecting Δ produces two right triangles with hypotenuse R and opposite side LC/2, so sin(Δ/2) equals (LC/2) / R, which rearranges to the long-chord identity LC = 2 R sin(Δ/2). That is the same trigonometric split used for any circular chord, but here the angle is the alignment deflection of the whole curve, not an arbitrary central angle on a geometry worksheet.

Input contract, angle units, response fields, and errors

The open interval keeps tan(Δ/2) and sec(Δ/2) finite, so a semicircle with the PI at infinity is rejected rather than returning an infinite tangent. Numeric results are rounded to twelve decimal places for stable goldens and automation. POST a JSON body with two required finite numbers: radius (aliases r, R), a positive length in any consistent unit; and deflection_angle (aliases deflection, delta, intersection_angle, i_angle, total_deflection, I), the total deflection Δ. Optional angle_unit (aliases unit, angleUnit) is the closed set deg or rad and defaults to deg, meaning decimal degrees. Degrees of arc, minutes, and seconds must be reduced to a decimal degree or a radian before the call. Fields may arrive as JSON numbers or numeric strings. Missing fields, non-finite values, a non-positive radius, an angle_unit other than deg or rad, or a deflection that is not strictly between 0 and 180 degrees (or 0 and π radians) fail with invalid_input naming the problem; those failures are not billed. On success the body echoes radius, deflection_angle_deg, deflection_angle_rad, and half_deflection_deg; returns long_chord and half_chord; and includes the companion elements tangent_length, curve_length, middle_ordinate, and external_distance, plus formula LC = 2 × R × sin(Δ/2), method circular_curve_long_chord, and a short message. Example: radius 300 and deflection 60 degrees yields long_chord 300, because 2 × 300 × sin(30°) is exactly 300 in the same length unit. Pair the response with your own stationing if you need PC, PI, and PT chainage; this endpoint solves the curve elements from R and Δ only.

Where a horizontal-curve long-chord API earns its keep

Alignment designers and construction surveyors need the long chord as soon as a radius and an intersection angle are chosen: it is the check distance between PC and PT, the base of the middle-ordinate offset, and the length that a GNSS baseline or a taped line should recover on the ground. Content sites that rank for horizontal curve long chord calculator, circular curve LC from radius and deflection, or survey long chord PC to PT benefit from a live free tool whose arithmetic matches the paid automation path byte-for-byte. Invalid input is not billed. Civil and transportation courses use LC = 2 R sin(Δ/2) in every circular-curve chapter; a deterministic oracle lets homework and LMS auto-graders mark the long chord, tangent, and arc length without a CAD seat. GIS and BIM pipelines that already store horizontal alignments can send R and Δ from a design file and pin long_chord, tangent_length, and curve_length into stakeout notes or quantity take-offs. Keep requests small, pin the rounded long_chord field in tests, and you get reproducible circular-curve elements for classroom widgets, field tablets, and API clients without standing up a highway-design CAD stack of your own.

Integration use cases

Surveying homework and LMS grading

Check LC = 2 R sin(Δ/2) and the companion circular-curve elements with a deterministic oracle students can also run in the free browser tool.

Stakeout notes and quantity take-offs

Send R and Δ from a design file and pin long_chord, tangent_length, and curve_length into stakeout sheets or earthwork length estimates.

Technical questions

What does the horizontal curve long chord calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free