The $radiansToDegrees operator converts an angle from radians to degrees in MongoDB aggregation pipelines. Use it when math stages produce radians but you need readable degree values for dashboards, APIs, or reports.
Convert angle units in pipelines.
One expression inside $radiansToDegrees.
Human-readable angle output.
radians × (180 / π).
Geospatial, sensors, reports.
Pair with $degreesToRadians.
In MongoDB’s aggregation framework, the $radiansToDegrees operator converts a numeric radian value into degrees. For example, π radians becomes 180 degrees, and π/2 radians becomes 90 degrees. This is the inverse of $degreesToRadians and is essential when trig operators like $asin or $acos return radians that users expect to see in degrees.
Think of $radiansToDegrees as the “display” step after math. MongoDB trig functions work in radians internally; convert back to degrees before showing angles on a map, chart, or API response.
The $radiansToDegrees operator takes one numeric expression (an angle in radians):
{ $radiansToDegrees: <expression> }$radiansToDegrees — multiplies the input by 180/π and returns degrees.<expression> — can be a field path ("$bearingRad"), a literal number, or another numeric expression.$project, $addFields, or $set.null, the result is null.MongoDB applies the standard math formula. Common radian values convert predictably:
| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (math / unit conversion) |
| Syntax | { $radiansToDegrees: <expression> } |
| Input | Angle in radians (any numeric value) |
| Output unit | Degrees |
| Inverse operator | $degreesToRadians |
{
$radiansToDegrees: 3.14159
}≈ 180° (π rad)
{
$radiansToDegrees: "$bearingRad"
}Convert stored radians
{
$radiansToDegrees: 1.5708
}≈ 90° (π/2 rad)
{
$radiansToDegrees: null
}Returns null
Start with angles stored in radians, convert them to degrees for display, and chain with inverse trig operators.
Use a locations collection with bearings in radians and convert them to degrees with $project.
Suppose you have a locations collection where each document stores a bearing in radians:
[
{ "_id": ObjectId("609c26812e9274a86871bc6a"), "name": "North Tower", "bearingRad": 0 },
{ "_id": ObjectId("609c26812e9274a86871bc6b"), "name": "East Gate", "bearingRad": 1.571 },
{ "_id": ObjectId("609c26812e9274a86871bc6c"), "name": "South Pier", "bearingRad": 3.142 }
]Convert each bearing from radians to degrees:
db.locations.aggregate([
{
$project: {
name: 1,
bearingRad: 1,
bearingDeg: { $radiansToDegrees: "$bearingRad" }
}
}
])0 radians → 0 degrees.1.571 radians (π/2) → 90 degrees.3.142 radians (π) → 180 degrees.Convert inverse trig results, add display fields, and validate common angle values.
Inverse trig operators return radians. Convert for human-readable output:
db.triangles.aggregate([
{
$project: {
sideA: 1,
sideB: 1,
sideC: 1,
angleRad: {
$acos: {
$divide: [
{
$subtract: [
{ $add: [
{ $pow: [ "$sideA", 2 ] },
{ $pow: [ "$sideB", 2 ] }
]},
{ $pow: [ "$sideC", 2 ] }
]
},
{ $multiply: [ 2, "$sideA", "$sideB" ] }
]
}
},
angleDeg: {
$radiansToDegrees: {
$acos: {
$divide: [
{
$subtract: [
{ $add: [
{ $pow: [ "$sideA", 2 ] },
{ $pow: [ "$sideB", 2 ] }
]},
{ $pow: [ "$sideC", 2 ] }
]
},
{ $multiply: [ 2, "$sideA", "$sideB" ] }
]
}
}
}
}
}
])$acos returns radians. Wrap the result with $radiansToDegrees so dashboards and APIs show familiar degree values like 60° instead of 1.047 radians.
Keep radian values for math but add degree fields for reporting:
db.sensors.aggregate([
{
$addFields: {
headingDeg: { $radiansToDegrees: "$headingRad" },
pitchDeg: { $radiansToDegrees: "$pitchRad" }
}
}
])Preserve precise radian fields for calculations while adding degree fields that operators and end users can read at a glance.
Common radian values every beginner should know:
db.samples.aggregate([
{
$project: {
deg0: { $radiansToDegrees: 0 }, // 0°
deg90: { $radiansToDegrees: 1.5708 }, // π/2 → 90°
deg180: { $radiansToDegrees: 3.14159 },// π → 180°
deg360: { $radiansToDegrees: 6.28319 } // 2π → 360°
}
}
])0 rad → 0°, π/2 rad → 90°, π rad → 180°, and 2π rad → 360°. Use these to validate pipeline logic or sanity-check conversions.
Convert degrees to radians and back to verify the inverse relationship:
db.locations.aggregate([
{
$project: {
bearingDeg: 1,
restoredDeg: {
$radiansToDegrees: {
$degreesToRadians: "$bearingDeg"
}
}
}
}
])
// restoredDeg should equal bearingDeg (within floating-point precision)$degreesToRadians followed by $radiansToDegrees reconstructs the original degree value. The two operators are mathematical inverses.
$acos, $asin, or $atan output in degrees.$degreesToRadians to verify angle conversions in ETL pipelines.$radiansToDegrees WorksThe pipeline evaluates the input — a field like "$bearingRad" or a numeric literal such as 3.14159.
MongoDB multiplies the value by 180/π to produce the equivalent angle in degrees.
The degree value is written to the field you define in $project or $addFields.
Human-readable angles for maps, charts, APIs, and operator dashboards.
The $radiansToDegrees operator converts radian angles to degrees in MongoDB aggregation pipelines. It is the display counterpart to $degreesToRadians and is essential when trig math produces radians but users expect degree values.
For beginners, the key idea is simple: wrap any radian expression in { $radiansToDegrees: ... } inside a stage like $project, and MongoDB returns the degree equivalent using the standard 180/π formula. Next in the series: $rand.
$radiansToDegrees after $acos, $asin, or $atan for display$degreesToRadians for round-trip conversions$ifNull when needed$radiansToDegrees with $degreesToRadians$radiansToDegrees as a query filter outside expressionsnull input returns null$radiansToDegrees by mistake$radiansToDegreesUse these points when converting angles in MongoDB pipelines.
Multiply by 180/π.
Purpose{ $radiansToDegrees: expr }
After inverse trig ops.
Usage$degreesToRadians.
Pairingnull in → null out.
Edge caseMove on to $rand for random values, or review $degreesToRadians for the inverse conversion.
5 people found this page helpful