Skip to main content

Angular Dimension

OCCT category icon with a stylized logo representation

Angular dimensions measure and display angles between two directions in your 3D models. They're essential for technical drawings, engineering documentation, and design verification where angular relationships matter. Bitbybit's angular dimension tools help you create professional angular annotations that automatically update when your geometry changes.

Understanding Angular Dimensions​

Angular dimensions measure the angle between two direction vectors and display them with arc lines, extension lines, and text labels. The system automatically calculates angles and formats the display. Key components include:

  • Direction Vectors: Two direction vectors that define the angle being measured
  • Center Point: The origin point from which the angle is measured
  • Arc Radius: Controls the size of the dimensional arc
  • Arc Offset: Positions the dimension arc relative to the center point
  • Label Customization: For text formatting, units (degrees/radians), and positioning
Bitbybit Platform

Simple angular dimension between two directions

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "a1b2c3d4e5f6g7h8": {
      "id": "a1b2c3d4e5f6g7h8",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "direction 1",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 1,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        7.482591014780979,
        58.460446270459585
      ]
    },
    "b2c3d4e5f6g7h8i9": {
      "id": "b2c3d4e5f6g7h8i9",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "direction 2",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 0,
        "y": 1,
        "z": 1
      },
      "inputs": {},
      "position": [
        10.061801916378727,
        411.1480178836501
      ]
    },
    "c3d4e5f6g7h8i9j0": {
      "id": "c3d4e5f6g7h8i9j0",
      "name": "bitbybit.occt.dimensions.simpleAngularDimension",
      "customName": "angular dimension",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "radius": 2,
        "offsetFromCenter": 0.3,
        "extraSize": 0.1,
        "decimalPlaces": 1,
        "labelSuffix": "deg",
        "labelSize": 0.3,
        "labelOffset": 0.4,
        "radians": false
      },
      "inputs": {
        "direction1": {
          "connections": [
            {
              "node": "a1b2c3d4e5f6g7h8",
              "output": "result",
              "data": {}
            }
          ]
        },
        "direction2": {
          "connections": [
            {
              "node": "b2c3d4e5f6g7h8i9",
              "output": "result",
              "data": {}
            }
          ]
        },
        "center": {
          "connections": [
            {
              "node": "d4e5f6g7h8i9j0k1",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        570.2450515032658,
        366.4814859166162
      ]
    },
    "d4e5f6g7h8i9j0k1": {
      "id": "d4e5f6g7h8i9j0k1",
      "name": "bitbybit.point.pointXYZ",
      "customName": "center",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 0,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        7.392071876593093,
        765.5571470674718
      ]
    }
  }
}

Angular dimensions update automatically when direction vectors change, keeping your documentation accurate throughout the design process.

Advanced Application: Cone Apex Angle​

Angular dimensions are particularly useful for complex 3D geometry like cones, where measuring the apex angle is crucial for manufacturing and design verification. Here's an advanced example that creates a cone and measures its apex angle using angular dimensions.

Bitbybit Platform

Cone with apex angle measurement

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "6000a6dba12c589b": {
      "id": "6000a6dba12c589b",
      "name": "bitbybit.occt.shapes.solid.createCone",
      "customName": "cone",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "radius1": 5,
        "radius2": 2.7,
        "height": 5,
        "angle": 360,
        "center": [
          0,
          0,
          0
        ],
        "direction": [
          0,
          1,
          0
        ]
      },
      "inputs": {
        "radius2": {
          "connections": [
            {
              "node": "0d1e3947d578b4ec",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        202.90127182006836,
        309.3927459716797
      ]
    },
    "3e6a6cd6b79a6182": {
      "id": "3e6a6cd6b79a6182",
      "name": "bitbybit.occt.transforms.rotate",
      "customName": "rotate",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "axis": [
          0,
          0,
          1
        ],
        "angle": -90
      },
      "inputs": {
        "shape": {
          "connections": [
            {
              "node": "6000a6dba12c589b",
              "output": "result",
              "data": {}
            }
          ]
        },
        "axis": {
          "connections": [
            {
              "node": "5d1a4a4710b9c534",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        848.8138999938965,
        506.81813049316406
      ]
    },
    "5d1a4a4710b9c534": {
      "id": "5d1a4a4710b9c534",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 0,
        "y": 1,
        "z": 0
      },
      "inputs": {},
      "position": [
        202.6703758239746,
        769.89697265625
      ]
    },
    "8de671c3eaab09de": {
      "id": "8de671c3eaab09de",
      "name": "bitbybit.occt.shapes.edge.getEdge",
      "customName": "get edge",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "index": 2
      },
      "inputs": {
        "shape": {
          "connections": [
            {
              "node": "3e6a6cd6b79a6182",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1266.594482421875,
        526.6192932128906
      ]
    },
    "02c13505f27ef023": {
      "id": "02c13505f27ef023",
      "name": "bitbybit.occt.shapes.edge.startPointOnEdge",
      "customName": "start point on edge",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        }
      },
      "inputs": {
        "shape": {
          "connections": [
            {
              "node": "e96ef03bcb659862",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        2118.7555152834793,
        709.4557218388306
      ]
    },
    "664b0a741d144723": {
      "id": "664b0a741d144723",
      "name": "bitbybit.occt.shapes.edge.endPointOnEdge",
      "customName": "end point on edge",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        }
      },
      "inputs": {
        "shape": {
          "connections": [
            {
              "node": "e96ef03bcb659862",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        2126.2934115796666,
        426.32490319306703
      ]
    },
    "0d5e7285ef133b23": {
      "id": "0d5e7285ef133b23",
      "name": "bitbybit.vector.sub",
      "customName": "sub",
      "async": false,
      "drawable": false,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        }
      },
      "inputs": {
        "first": {
          "connections": [
            {
              "node": "664b0a741d144723",
              "output": "result",
              "data": {}
            }
          ]
        },
        "second": {
          "connections": [
            {
              "node": "02c13505f27ef023",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        2598.625898772063,
        482.4246994017498
      ]
    },
    "d23e3fb576119851": {
      "id": "d23e3fb576119851",
      "name": "bitbybit.occt.dimensions.simpleAngularDimension",
      "customName": "simple angular dimension",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "direction1": [
          1,
          0,
          0
        ],
        "direction2": [
          0,
          0,
          1
        ],
        "center": [
          0,
          0,
          0
        ],
        "radius": 7,
        "offsetFromCenter": 2,
        "extraSize": 0,
        "decimalPlaces": 2,
        "labelSuffix": "(deg)",
        "labelSize": 0.4,
        "labelOffset": 0.6,
        "radians": false
      },
      "inputs": {
        "center": {
          "connections": [
            {
              "node": "02c13505f27ef023",
              "output": "result",
              "data": {}
            }
          ]
        },
        "direction1": {
          "connections": [
            {
              "node": "0d5e7285ef133b23",
              "output": "result",
              "data": {}
            }
          ]
        },
        "direction2": {
          "connections": [
            {
              "node": "730d89b2fe4fb666",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        3071.0977587390807,
        628.4791643359932
      ]
    },
    "730d89b2fe4fb666": {
      "id": "730d89b2fe4fb666",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": -1,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        2612.4858041717157,
        868.4008088631837
      ]
    },
    "e96ef03bcb659862": {
      "id": "e96ef03bcb659862",
      "name": "bitbybit.occt.transforms.translate",
      "customName": "translate",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "translation": [
          0,
          0,
          0
        ]
      },
      "inputs": {
        "shape": {
          "connections": [
            {
              "node": "8de671c3eaab09de",
              "output": "result",
              "data": {}
            }
          ]
        },
        "translation": {
          "connections": [
            {
              "node": "62a462cd9e796c3e",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1670.0430847458426,
        523.7570313182497
      ]
    },
    "62a462cd9e796c3e": {
      "id": "62a462cd9e796c3e",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": -1,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        1269.73587503378,
        839.2057481256558
      ]
    },
    "0d1e3947d578b4ec": {
      "id": "0d1e3947d578b4ec",
      "name": "bitbybit.math.numberSlider",
      "customName": "number slider",
      "data": {
        "options": {
          "min": 1,
          "max": 10,
          "step": 0.1,
          "width": 350,
          "updateOnDrag": false
        },
        "number": 1.1
      },
      "inputs": {},
      "position": [
        -343.14900917979224,
        396.4478118682945
      ]
    }
  }
}

This example demonstrates how angular dimensions can be applied to complex 3D geometry. The cone's apex angle is measured between two direction vectors from the apex to opposite points on the base circumference. As you adjust the cone's radius or height, the apex angle automatically updates, making this perfect for manufacturing documentation and design verification.

Dimension Properties and Customization​

Angular dimensions offer extensive customization options to match your documentation standards and specific use cases.

Essential Parameters​

Direction Vectors define the two directions between which the angle is measured. These can be:

  • Fixed direction vectors like [1, 0, 0] and [0, 1, 0]
  • Calculated vectors from geometry using vectorXYZ
  • Dynamic vectors that change based on parameters

Center Point is the origin from which the angle is measured. This should typically be:

  • The vertex where the two directions meet
  • A significant geometric point in your design
  • Positioned for optimal dimension visibility

Radius controls the size of the dimensional arc. Larger radii provide:

  • Better visibility in complex drawings
  • More space for dimension text
  • Clearer separation from geometry

Offset from Center moves the dimension arc away from the center point:

  • Positive values move the arc outward
  • Negative values move it inward
  • Use this to avoid overlapping with geometry

Label Formatting​

Decimal Places controls measurement precision:

  • Use 0-1 decimals for rough angles
  • Use 2-3 decimals for precision machining
  • Consider the manufacturing tolerance requirements

Label Suffix adds context to measurements:

  • "deg" for simple degree notation
  • "deg apex" for specific angle types
  • "(deg)" for formal documentation
  • "rad" when using radians

Radians vs Degrees can be controlled with the radians property:

  • false (default) displays angles in degrees (0-360 deg)
  • true displays angles in radians (0-2π)

Label Size and Offset control text appearance:

  • Scale label size for viewing distance and drawing scale
  • Use label offset to position text optimally
  • Consider text readability at different zoom levels

Extra Size controls the length of extension lines:

  • Helps connect the dimension to referenced geometry
  • Useful when the center point is far from the measured elements
  • Improves dimension clarity in complex drawings

Best Practices​

Angular dimensions serve critical functions in engineering and manufacturing workflows, communicating design intent for machined angles, verifying angular tolerances, and ensuring proper fit between angled components. Position dimensions near the vertex where angles originate, use appropriate radius values to avoid crowding, and maintain consistent formatting throughout your documentation.

These dimensions excel in machining operations for documenting drill and chamfer angles, structural design for measuring beam and joint angles, and quality control for checking manufactured parts against specifications. When integrated with parametric design workflows, they become especially powerful by automatically updating as design parameters change, validating constraints, and creating interactive documentation.

Angular dimensions bridge the critical gap between design intent and manufacturing reality. They provide a common language for communicating angular relationships in collaborative environments, eliminate manual calculations, and reduce downstream errors. Whether you're working with simple geometric relationships or complex 3D assemblies like the cone apex angle example, mastering angular dimensions improves documentation quality and clarity, leading to reduced errors, faster manufacturing, and clearer communication across your entire design and production workflow.