Skip to main content

Edge Primitives

OCCT category icon with a stylized logo representation

Edge primitives are the fundamental building blocks for creating geometric boundaries in 3D modeling. In OCCT (Open CASCADE Technology), edges define the boundaries between faces and form the skeleton of complex 3D shapes. This tutorial covers the essential edge types you'll use in most modeling scenarios.

What You'll Learn​

In this tutorial, you'll discover how to create:

  • Linear edges - straight lines between two points
  • Circular arcs - curved segments using various definition methods
  • Complete circles - closed circular boundaries
  • Elliptical edges - oval-shaped curves with dual radii

Each example is provided in three formats: Rete (visual node-based), Blockly (block-based), and TypeScript (code-based), so you can learn using your preferred approach.

Why Edge Primitives Matter​

Understanding edge primitives is crucial because:

  • They form the boundaries of all 3D shapes
  • They enable precise geometric control in your models
  • They provide multiple creation methods for different design scenarios
  • They serve as the foundation for more complex geometric operations

Let's start with the most basic edge primitive - the line edge.

Bitbybit Platform

Creating primitive solids

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "95d786dcd4c56129": {
      "id": "95d786dcd4c56129",
      "name": "bitbybit.occt.shapes.edge.line",
      "customName": "line",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "start": [
          0,
          0,
          0
        ],
        "end": [
          0,
          1,
          0
        ]
      },
      "inputs": {
        "start": {
          "connections": [
            {
              "node": "7c324685a8416e59",
              "output": "result",
              "data": {}
            }
          ]
        },
        "end": {
          "connections": [
            {
              "node": "ffc85d04b421e501",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        935.133850142149,
        303.38593169102637
      ]
    },
    "7c324685a8416e59": {
      "id": "7c324685a8416e59",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": -5,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        373.89453125,
        135.734375
      ]
    },
    "ffc85d04b421e501": {
      "id": "ffc85d04b421e501",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 5,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        376.609375,
        493.1484375
      ]
    }
  }
}

Line Edge​

This example demonstrates how to create a simple straight line edge in 3D space. A line edge is the most basic type of edge primitive, defined by two points: a start point and an end point.

What's happening:

  • We define two points: startPoint at [-5, 0, 0] and endPoint at [5, 0, 0]
  • These points create a horizontal line along the X-axis, 10 units long
  • The LineDto object packages our start and end points for the OCCT line creation function
  • The result is a straight edge that can be used in more complex geometries or displayed on its own

Key concepts:

  • Start and End Points: Every line needs exactly two points to define its position and direction
  • 3D Coordinates: Points are specified as [x, y, z] coordinates in 3D space
  • Edge vs Line: An edge is a geometric boundary that can be part of a face or solid, while a line is the mathematical definition
Bitbybit Platform

Arc edge through 3 points

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "7c324685a8416e59": {
      "id": "7c324685a8416e59",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": -5,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        407.27152338242496,
        28.397666819319923
      ]
    },
    "ffc85d04b421e501": {
      "id": "ffc85d04b421e501",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 5,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        398.7292096351899,
        756.692501905938
      ]
    },
    "3d68f48c12708bfb": {
      "id": "3d68f48c12708bfb",
      "name": "bitbybit.occt.shapes.edge.arcThroughThreePoints",
      "customName": "arc through three points",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "start": [
          0,
          0,
          0
        ],
        "middle": [
          0,
          1,
          0
        ],
        "end": [
          0,
          0,
          1
        ]
      },
      "inputs": {
        "start": {
          "connections": [
            {
              "node": "7c324685a8416e59",
              "output": "result",
              "data": {}
            }
          ]
        },
        "end": {
          "connections": [
            {
              "node": "ffc85d04b421e501",
              "output": "result",
              "data": {}
            }
          ]
        },
        "middle": {
          "connections": [
            {
              "node": "dbc242d287977e7c",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1066.9435736855678,
        341.1003151875607
      ]
    },
    "dbc242d287977e7c": {
      "id": "dbc242d287977e7c",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 0,
        "y": 6,
        "z": 0
      },
      "inputs": {},
      "position": [
        403.21247949687677,
        385.92908959314644
      ]
    }
  }
}

Arc Through Three Points​

This example shows how to create an arc edge that passes through three specific points. This is one of the most intuitive ways to define an arc since you can directly control three points that the arc must pass through.

What's happening:

  • We define three points: startPoint at [-5, 0, 0], midPoint at [0, 6, 0], and endPoint at [5, 0, 0]
  • The arc starts at the first point, curves through the middle point, and ends at the third point
  • OCCT automatically calculates the circular arc that best fits these three points
  • The middle point determines how much the arc curves - higher Y values create more pronounced curves

Key concepts:

  • Three-Point Definition: The arc is uniquely defined by exactly three non-collinear points
  • Curve Direction: The order of points matters - the arc flows from start to middle to end
  • Geometric Constraint: The three points cannot be in a straight line (collinear) as this wouldn't define a unique arc
Bitbybit Platform

Arc edge from two points and tangent

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "7c324685a8416e59": {
      "id": "7c324685a8416e59",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": -5,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        407.27152338242496,
        28.397666819319923
      ]
    },
    "ffc85d04b421e501": {
      "id": "ffc85d04b421e501",
      "name": "bitbybit.vector.vectorXYZ",
      "customName": "vector xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 5,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        398.7292096351899,
        756.692501905938
      ]
    },
    "b8be5b2f57d0fdff": {
      "id": "b8be5b2f57d0fdff",
      "name": "bitbybit.occt.shapes.edge.arcThroughTwoPointsAndTangent",
      "customName": "arc through two points and tangent",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "start": [
          0,
          0,
          0
        ],
        "tangentVec": [
          0,
          1,
          0
        ],
        "end": [
          0,
          0,
          1
        ]
      },
      "inputs": {
        "start": {
          "connections": [
            {
              "node": "7c324685a8416e59",
              "output": "result",
              "data": {}
            }
          ]
        },
        "end": {
          "connections": [
            {
              "node": "ffc85d04b421e501",
              "output": "result",
              "data": {}
            }
          ]
        },
        "tangentVec": {
          "connections": [
            {
              "node": "efafce24c1d0df6e",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1830.1366458305074,
        296.5007789636968
      ]
    },
    "dca4efae87f6bfab": {
      "id": "dca4efae87f6bfab",
      "name": "bitbybit.point.pointXYZ",
      "customName": "point xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": -2,
        "y": 3,
        "z": 0
      },
      "inputs": {},
      "position": [
        405.11746168870525,
        383.2258817291941
      ]
    },
    "efafce24c1d0df6e": {
      "id": "efafce24c1d0df6e",
      "name": "bitbybit.vector.sub",
      "customName": "sub",
      "async": false,
      "drawable": false,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        }
      },
      "inputs": {
        "second": {
          "connections": [
            {
              "node": "dca4efae87f6bfab",
              "output": "result",
              "data": {}
            }
          ]
        },
        "first": {
          "connections": [
            {
              "node": "7c324685a8416e59",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        946.71445993969,
        341.56236361525805
      ]
    },
    "b39948feb5637468": {
      "id": "b39948feb5637468",
      "name": "bitbybit.line.create",
      "customName": "line",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        }
      },
      "inputs": {
        "end": {
          "connections": [
            {
              "node": "dca4efae87f6bfab",
              "output": "result",
              "data": {}
            }
          ]
        },
        "start": {
          "connections": [
            {
              "node": "7c324685a8416e59",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        942.5678589949399,
        -159.11706305406148
      ]
    }
  }
}

Arc From Two Points and Tangent​

This example demonstrates creating an arc using two endpoints and a tangent vector that controls the arc's curvature at the start point. This method gives you precise control over both the arc's endpoints and its initial direction.

What's happening:

  • We define two endpoints: startPoint at [-5, 0, 0] and endPoint at [5, 0, 0]
  • We create a tangent vector by subtracting two points: from startPoint to vecEndPt at [-2, 3, 0]
  • This tangent vector controls how the arc curves away from the start point
  • The arc begins at the start point, follows the tangent direction initially, then curves to reach the end point

Key concepts:

  • Tangent Vector: Defines the direction the arc travels when leaving the start point
  • Vector Calculation: We calculate the tangent by finding the direction from one point to another
  • Curvature Control: The tangent vector's direction and magnitude influence how sharply the arc curves
  • Helper Visualization: The example draws additional lines to show the tangent direction and reference points
Bitbybit Platform

Arc edge from circle and two points

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "e25a36dbd1221d72": {
      "id": "e25a36dbd1221d72",
      "name": "bitbybit.occt.shapes.edge.arcFromCircleAndTwoPoints",
      "customName": "arc from circle and two points",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "start": [
          0,
          0,
          0
        ],
        "end": [
          0,
          0,
          1
        ],
        "sense": true
      },
      "inputs": {
        "circle": {
          "connections": [
            {
              "node": "de7fe612b72208fd",
              "output": "result",
              "data": {}
            }
          ]
        },
        "start": {
          "connections": [
            {
              "node": "cc2276449de22a3f",
              "output": "result",
              "data": {}
            }
          ]
        },
        "end": {
          "connections": [
            {
              "node": "fb27e3b0bf9b5d7d",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1481.4367281371424,
        452.12685842894257
      ]
    },
    "de7fe612b72208fd": {
      "id": "de7fe612b72208fd",
      "name": "bitbybit.occt.shapes.edge.createCircleEdge",
      "customName": "circle edge",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "radius": 5,
        "center": [
          0,
          0,
          0
        ],
        "direction": [
          0,
          1,
          0
        ]
      },
      "inputs": {},
      "position": [
        439.6473003398374,
        261.1804551322216
      ]
    },
    "cc2276449de22a3f": {
      "id": "cc2276449de22a3f",
      "name": "bitbybit.point.pointXYZ",
      "customName": "point xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 8,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        440.1276198123209,
        621.0361775861882
      ]
    },
    "fb27e3b0bf9b5d7d": {
      "id": "fb27e3b0bf9b5d7d",
      "name": "bitbybit.point.pointXYZ",
      "customName": "point xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 8,
        "y": 0,
        "z": 8
      },
      "inputs": {},
      "position": [
        440.9645672422918,
        964.0048762806854
      ]
    },
    "fb4005d4348546cc": {
      "id": "fb4005d4348546cc",
      "name": "bitbybit.point.pointXYZ",
      "customName": "point xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 0,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        439.58981688143535,
        1310.3979292282452
      ]
    },
    "3c732b6847855d91": {
      "id": "3c732b6847855d91",
      "name": "bitbybit.lists.createList",
      "customName": "create list",
      "data": {},
      "inputs": {
        "listElements": {
          "connections": [
            {
              "node": "fb4005d4348546cc",
              "output": "result",
              "data": {}
            },
            {
              "node": "cc2276449de22a3f",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1050.9359151609785,
        975.9092246916315
      ]
    },
    "d9ef00038143f721": {
      "id": "d9ef00038143f721",
      "name": "bitbybit.lists.createList",
      "customName": "create list",
      "data": {},
      "inputs": {
        "listElements": {
          "connections": [
            {
              "node": "fb4005d4348546cc",
              "output": "result",
              "data": {}
            },
            {
              "node": "fb27e3b0bf9b5d7d",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1073.3608326580068,
        1211.105160335817
      ]
    },
    "ed0819b2fb57be80": {
      "id": "ed0819b2fb57be80",
      "name": "bitbybit.draw.drawAnyAsync",
      "customName": "draw any async",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        }
      },
      "inputs": {
        "entity": {
          "connections": [
            {
              "node": "3c732b6847855d91",
              "output": "list",
              "data": {}
            },
            {
              "node": "d9ef00038143f721",
              "output": "list",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1497.2032698882226,
        1038.4762109266621
      ]
    }
  }
}

Arc From Circle and Two Points​

This example shows how to create an arc by extracting a portion of an existing circle edge between two specified points. This method is useful when you want to create an arc that follows a specific circular path.

What's happening:

  • First, we create a complete circle edge with radius 5, centered at the origin
  • We define two points: startPoint at [8, 0, 0] and endPoint at [8, 0, 8]
  • The system finds where these points would intersect the circle (projected onto the circle if needed)
  • An arc is created along the circle's circumference between these two intersection points
  • Helper lines are drawn to visualize the relationship between the center and the arc endpoints

Key concepts:

  • Base Circle: The arc follows the exact curvature of the parent circle
  • Point Projection: Points are projected onto the circle to find valid start/end positions
  • Arc Direction: The sense parameter controls whether the arc goes clockwise or counterclockwise
  • Geometric Relationship: The resulting arc maintains the same radius and center as the original circle
Bitbybit Platform

Arc edge from circle and two angles

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "de7fe612b72208fd": {
      "id": "de7fe612b72208fd",
      "name": "bitbybit.occt.shapes.edge.createCircleEdge",
      "customName": "circle edge",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "radius": 5,
        "center": [
          0,
          0,
          0
        ],
        "direction": [
          0,
          1,
          0
        ]
      },
      "inputs": {},
      "position": [
        439.6473003398374,
        261.1804551322216
      ]
    },
    "3ebf6ed731a27ccd": {
      "id": "3ebf6ed731a27ccd",
      "name": "bitbybit.occt.shapes.edge.arcFromCircleAndTwoAngles",
      "customName": "arc from circle and two angles",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "alphaAngle1": 45,
        "alphaAngle2": 270,
        "sense": true
      },
      "inputs": {
        "circle": {
          "connections": [
            {
              "node": "de7fe612b72208fd",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        813.5579416874897,
        259.5200448916267
      ]
    }
  }
}

Arc From Circle and Two Angles​

This example demonstrates creating an arc by specifying a base circle and two angular positions. This method provides precise control over the arc's span using angle measurements.

What's happening:

  • We start with a circle edge (radius 5, centered at origin)
  • Two angles are specified: alphaAngle1 at 45° and alphaAngle2 at 270°
  • The arc is created between these two angular positions on the circle
  • The result is a portion of the circle spanning from 45° to 270° (a 225° arc)

Key concepts:

  • Angular Definition: Angles are measured in degrees from a reference direction (typically the positive X-axis)
  • Arc Span: The difference between the two angles determines how much of the circle becomes the arc
  • Direction Control: The sense parameter determines if the arc goes from angle1 to angle2 or the other way
  • Precise Control: This method is ideal when you know exactly what angular portion of a circle you need
Bitbybit Platform

Arc edge from circle point and an angle

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "de7fe612b72208fd": {
      "id": "de7fe612b72208fd",
      "name": "bitbybit.occt.shapes.edge.createCircleEdge",
      "customName": "circle edge",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": true,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "radius": 5,
        "center": [
          0,
          0,
          0
        ],
        "direction": [
          0,
          1,
          0
        ]
      },
      "inputs": {},
      "position": [
        440.37396475016214,
        611.5486579955054
      ]
    },
    "fb27e3b0bf9b5d7d": {
      "id": "fb27e3b0bf9b5d7d",
      "name": "bitbybit.point.pointXYZ",
      "customName": "point xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 8,
        "y": 0,
        "z": 8
      },
      "inputs": {},
      "position": [
        440.9645672422918,
        964.0048762806854
      ]
    },
    "fb4005d4348546cc": {
      "id": "fb4005d4348546cc",
      "name": "bitbybit.point.pointXYZ",
      "customName": "point xyz",
      "async": false,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "x": 0,
        "y": 0,
        "z": 0
      },
      "inputs": {},
      "position": [
        439.58981688143535,
        1310.3979292282452
      ]
    },
    "ed0819b2fb57be80": {
      "id": "ed0819b2fb57be80",
      "name": "bitbybit.draw.drawAnyAsync",
      "customName": "draw any async",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        }
      },
      "inputs": {
        "entity": {
          "connections": [
            {
              "node": "35eb27049898c3e0",
              "output": "list",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1499.5146811508514,
        1169.414953289222
      ]
    },
    "35eb27049898c3e0": {
      "id": "35eb27049898c3e0",
      "name": "bitbybit.lists.createList",
      "customName": "create list",
      "data": {},
      "inputs": {
        "listElements": {
          "connections": [
            {
              "node": "fb4005d4348546cc",
              "output": "result",
              "data": {}
            },
            {
              "node": "fb27e3b0bf9b5d7d",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1073.3608326580068,
        1211.105160335817
      ]
    },
    "d66c2f3c7a5ecf3e": {
      "id": "d66c2f3c7a5ecf3e",
      "name": "bitbybit.occt.shapes.edge.arcFromCirclePointAndAngle",
      "customName": "arc from circle point and angle",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "alphaAngle": 360,
        "sense": true
      },
      "inputs": {
        "circle": {
          "connections": [
            {
              "node": "de7fe612b72208fd",
              "output": "result",
              "data": {}
            }
          ]
        },
        "point": {
          "connections": [
            {
              "node": "fb27e3b0bf9b5d7d",
              "output": "result",
              "data": {}
            }
          ]
        }
      },
      "position": [
        1498.7026123535022,
        721.27863949326
      ]
    }
  }
}

Arc From Circle, Point and Angle​

This example shows how to create an arc starting from a specific point on a circle and extending through a specified angular distance. This method combines point-based positioning with angular measurement.

What's happening:

  • We create a base circle (radius 5, centered at origin)
  • A starting point is defined at [8, 0, 8] which gets projected onto the circle
  • An angle of 360° is specified, creating a complete circular arc (full circle)
  • The arc begins at the projected point location and sweeps through the specified angle
  • Helper elements show the center point, the reference point, and connecting lines

Key concepts:

  • Point Projection: The specified point is projected onto the circle to find the actual start position
  • Angular Sweep: The angle determines how far around the circle the arc extends
  • Complete Circle: A 360° angle creates a full circular arc, essentially recreating the original circle
  • Starting Position: Unlike other methods, this gives you control over exactly where on the circle the arc begins
Bitbybit Platform

Circle edge

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "e754089939e32a7e": {
      "id": "e754089939e32a7e",
      "name": "bitbybit.occt.shapes.edge.createCircleEdge",
      "customName": "circle edge",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "radius": 5,
        "center": [
          0,
          0,
          0
        ],
        "direction": [
          0,
          1,
          0
        ]
      },
      "inputs": {},
      "position": [
        462.0703125,
        344.1484375
      ]
    }
  }
}

Circle Edge​

This example demonstrates creating a complete circular edge, which is one of the most fundamental curved primitives in 3D modeling. A circle edge represents a perfect circular boundary that can be used as a standalone geometry or as part of more complex shapes.

What's happening:

  • We define a circle with radius 5 units, centered at the origin [0, 0, 0]
  • The direction vector [0, 1, 0] specifies that the circle lies in a plane perpendicular to the Y-axis (horizontal plane)
  • The CircleDto object packages all the circle parameters for the OCCT creation function
  • The result is a complete circular edge that forms a closed loop

Key concepts:

  • Radius: Determines the size of the circle (distance from center to edge)
  • Center Point: The position in 3D space where the circle is located
  • Direction Vector: Defines the orientation of the plane containing the circle
  • Closed Curve: A circle is a closed curve, meaning it has no start or end points
Bitbybit Platform

Ellipse edge

rete logoRete
Script Source (rete)
{
  "id": "rete-v2-json",
  "nodes": {
    "8e0841446d50e41b": {
      "id": "8e0841446d50e41b",
      "name": "bitbybit.occt.shapes.edge.createEllipseEdge",
      "customName": "ellipse edge",
      "async": true,
      "drawable": true,
      "data": {
        "genericNodeData": {
          "hide": false,
          "oneOnOne": false,
          "flatten": 0,
          "forceExecution": false
        },
        "center": [
          0,
          0,
          0
        ],
        "direction": [
          0,
          1,
          0
        ],
        "radiusMinor": 3,
        "radiusMajor": 10
      },
      "inputs": {},
      "position": [
        360.29296875,
        401.90234375
      ]
    }
  }
}

Ellipse Edge​

This example demonstrates creating an elliptical edge, which is an oval-shaped curve that extends the concept of a circle to have two different radii. Ellipses are commonly used in technical drawings and 3D modeling for creating elongated circular shapes.

What's happening:

  • We define an ellipse centered at the origin [0, 0, 0]
  • The direction vector [0, 1, 0] specifies the orientation plane (horizontal, like the circle)
  • Two radii are specified: radiusMinor = 3 (shorter radius) and radiusMajor = 10 (longer radius)
  • The result is an oval shape that is 20 units wide and 6 units tall
  • The EllipseDto object packages all parameters for the OCCT creation function

Key concepts:

  • Major Radius: The longer radius that defines the ellipse's widest dimension
  • Minor Radius: The shorter radius that defines the ellipse's narrower dimension
  • Aspect Ratio: The relationship between major and minor radii determines how "stretched" the ellipse appears
  • Closed Curve: Like a circle, an ellipse is a closed curve with no endpoints
  • Geometric Relationship: When major and minor radii are equal, the ellipse becomes a perfect circle