Curves, Surfaces and Meshes

Start with the simplest step up from a single point: connect several in order and you have a polyline - a chain of straight segments. It is nothing more than a list of points understood as go from this one to the next, in sequence. A room outline, a setting-out path, a section profile - all are polylines, and because a polyline is just a list, everything you learned about lists applies directly.

import math

def polyline_length(pts):
    total = 0.0
    for a, b in zip(pts, pts[1:]):
        total += math.hypot(b[0] - a[0], b[1] - a[1])
    return total

path = [(0, 0), (3, 0), (3, 4)]
print(polyline_length(path))   # 7.0

The zip(pts, pts[1:]) trick pairs each point with the next one - a clean way to walk the segments of a polyline rather than its points. To close the polyline into a polygon (a room, a plot boundary) you simply treat the last point as joined back to the first, which the geometry algorithms in the next lesson do with pts[(i + 1) % n].

A polyline is exact and lightweight, which is why it is the natural representation for plans, boundaries and anything made of straight runs. Its limitation is right there in the name: it can only be straight between points. Approximate a curve with a polyline and you get a faceted, many-segment thing - fine for analysis, wrong for a smooth handrail. For genuine curves, we need something cleverer.

The curves in Rhino, Illustrator and most CAD are not polylines but NURBS - Non-Uniform Rational B-Splines. The name is a mouthful; the idea is graspable. A NURBS curve is defined not by points it passes through but by a handful of control points that pull the curve toward them, like magnets shaping a smooth wire. Move a control point and the curve flexes smoothly - which is exactly the responsive, editable behaviour a designer wants.

You almost never build a NURBS curve from raw numbers by hand; instead the tool or library does the maths and you supply the control points and a couple of settings (the degree, which controls smoothness, and a knot vector, which you can usually ignore at first). Conceptually, then, even a freeform curve reduces to a list of control points plus some rules for interpolating between them - data again, just richer data.

# A NURBS curve, conceptually: control points plus a degree.
control_points = [(0, 0), (2, 5), (6, 5), (8, 0)]
degree = 3   # cubic: smooth, the common default
# In rhino3dm or Grasshopper you would pass exactly these to a
# NurbsCurve constructor; the library computes the smooth path.

The practical takeaways are two. First, a NURBS curve is resolution-independent - it is a true smooth mathematical curve, not an approximation, so it stays crisp at any zoom. Second, when you script curves in Module 6 you will mostly be assembling control points (which are just points, from Lesson 5.1) and handing them to a library. The scary acronym hides a familiar core.

One distinction worth carrying: control points usually pull the curve toward them without the curve passing through each one - only the endpoints are touched. If you instead have points the curve must pass through (a survey of a road centreline, say), you want an interpolated curve, and libraries offer a separate call for that (often named something like CreateInterpolatedCurve). Knowing which behaviour you need - shaped-by versus passing-through - is the practical decision; the library handles the mathematics either way.

Push the idea one dimension further and a curve becomes a surface. Where a NURBS curve is shaped by a row of control points, a NURBS surface is shaped by a whole grid of them - imagine a rubber sheet with a mesh of handles you can pull in and out to sculpt hills and valleys. A flat wall, a curved façade, a doubly-curved roof: all are surfaces defined by a grid of control points and the same smooth-interpolation rules as curves, now running in two directions (often called u and v).

Most surface creation in practice is not done control-point by control-point but by operations: extrude a profile curve, loft between several curves, sweep a section along a rail, revolve a profile around an axis. Each takes curves you already have and produces a surface - and in a script each is a single function call. That is worth holding onto: you rarely place surface control points by hand; you describe a surface as an operation on curves. This is why the curve work matters so much: get your profile and rail curves right, and the surface follows almost for free. A great deal of parametric modelling is really curve wrangling - building and adjusting the curves - with a surface operation on the end.

The data view still holds. A surface stores its grid of control points, its degrees in each direction, and its knot data, plus a domain (the range of u and v). When you evaluate a surface at some (u, v) you get back a point in space - which is how tools drape panels, place components, or sample a façade. You do not need that machinery yet; you need the picture: a surface is a curve idea stretched into a sheet, still built from points and rules.

NURBS are exact and smooth, but for rendering, 3D printing, game engines, analysis and file interchange the world mostly uses meshes. A mesh approximates any shape with lots of flat facets - usually triangles or quadrilaterals - and its data structure is beautifully simple and the most important one to know in this lesson: a list of vertices and a list of faces.

The vertices are just points - (x, y, z) tuples - stored in a list, so each has an index (0, 1, 2, ...). The faces do not repeat coordinates; instead each face is a small tuple of vertex indices saying which corners to connect. This indirection is the whole trick: shared corners are stored once and referred to by number.

vertices = [
    (0, 0, 0),   # index 0
    (4, 0, 0),   # index 1
    (4, 4, 0),   # index 2
    (0, 4, 0),   # index 3
]
faces = [
    (0, 1, 2),   # a triangle using corners 0, 1, 2
    (0, 2, 3),   # a triangle using corners 0, 2, 3
]
print(len(vertices), "vertices,", len(faces), "faces")   # 4 vertices, 2 faces

Those two lists are the flat square, split into two triangles. Every OBJ, STL and glTF file, every Rhino or Blender mesh, is this pattern at heart - often with millions of entries, but the same two lists. Because faces reference shared vertices by index, moving one vertex updates every face that uses it, and the file stays compact. Once you can read a mesh as vertices plus faces, model files stop being opaque and become data you can generate, inspect and edit.

So which do you use? The choice is not about taste; each representation is good at different things, and picking wrongly makes scripts harder than they need to be. A quick guide:

Polylines and polygons for exact, straight-edged 2D: plans, boundaries, setting-out, anything you will measure areas from (Lesson 5.4). Lightweight and precise. NURBS curves and surfaces for smooth, editable, resolution-independent design geometry - the freeform façade, the curved stair, anything that must stay crisp and be reshaped by moving control points. Meshes for display, fabrication, analysis and interchange - when you need to render, 3D-print, run a simulation, or hand geometry to another program.

Real workflows convert between them constantly: you design with NURBS, then mesh it to render or print; you analyse a site as a mesh but set out with polylines. Knowing that a mesh is denser but approximate, and a NURBS surface is exact but heavier to work with, tells you which way to convert and what you lose each time (meshing a curved surface throws away smoothness; you cannot get it back by un-meshing).

For scripting, the headline is liberating: whichever you pick, it bottoms out in the points and lists you already handle. A polyline is a list of points; a NURBS curve is control points plus rules; a mesh is vertices plus faces. The intimidating variety of 3D geometry is a small number of data structures wearing different clothes - and Module 6 puts real Rhino and Grasshopper tools on top of exactly these ideas.

It also helps to know that solids - a wall, a slab, a mullion - are usually one of these representations in disguise: either a closed mesh (a watertight bag of faces) or a set of trimmed NURBS surfaces stitched into a shell, often called a BRep or boundary representation. You will meet that word in Rhino and in BIM tools, and it need not intimidate: it is surfaces bounding a volume, which is surfaces, which is control points, which is points. The whole tower rests on the atom from Lesson 5.1, and that is genuinely all there is underneath even the most elaborate model.