# Basics¶

In order to generate a spline shape with NURBS-Python, you need 3 components:

- degree
- knot vector
- control points

The number of components depend on the parametric dimensionality of the shape regardless of the spatial dimensionality.

**curve**is parametrically 1-dimensional (or 1-manifold)**surface**is parametrically 2-dimensional (or 2-manifold)**volume**is parametrically 3-dimensional (or 3-manifold)

Parametric dimensions are defined by `u`

, `v`

, `w`

and spatial dimensions are defined by `x`

, `y`

, `z`

.

## Working with the curves¶

In this section, we will cover the basics of spline curve generation using NURBS-Python. The following code snippet is an example to a 3-dimensional curve.

1 2 3 4 5 6 7 8 9 10 11 12 13 | ```
from geomdl import BSpline
# Create the curve instance
crv = BSpline.Curve()
# Set degree
crv.degree = 2
# Set control points
crv.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Set knot vector
crv.knotvector = [0, 0, 0, 1, 1, 1]
``` |

As described in the introduction text, we set the 3 required components to generate a 3-dimensional spline curve.

### Evaluating the curve points¶

The code snippet is updated to retrieve evaluated curve points.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | ```
from geomdl import BSpline
# Create the curve instance
crv = BSpline.Curve()
# Set degree
crv.degree = 2
# Set control points
crv.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Set knot vector
crv.knotvector = [0, 0, 0, 1, 1, 1]
# Get curve points
points = crv.evalpts
# Do something with the evaluated points
for pt in points:
print(pt)
``` |

`evalpts`

property will automatically call `evaluate()`

function.

### Getting the curve point at a specific parameter¶

`evaluate_single`

method will return the point evaluated as the specified parameter.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | ```
from geomdl import BSpline
# Create the curve instance
crv = BSpline.Curve()
# Set degree
crv.degree = 2
# Set control points
crv.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Set knot vector
crv.knotvector = [0, 0, 0, 1, 1, 1]
# Get curve point at u = 0.5
point = crv.evaluate_single(0.5)
``` |

### Setting the evaluation delta¶

Evaluation delta is used to change the number of evaluated points. Increasing the number of points will result in a
bigger evaluated points array, as described with `evalpts`

property and decreasing will reduce the size of the
`evalpts`

array. Therefore, evaluation delta can also be used to change smoothness of the plots generated using
the visualization modules.

`delta`

property will set the evaluation delta. It is also possible to use `sample_size`

property to set the number
of evaluated points.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ```
from geomdl import BSpline
# Create the curve instance
crv = BSpline.Curve()
# Set degree
crv.degree = 2
# Set control points
crv.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Set knot vector
crv.knotvector = [0, 0, 0, 1, 1, 1]
# Set evaluation delta
crv.delta = 0.005
# Get evaluated points
points_a = crv.evalpts
# Update delta
crv.delta = 0.1
# The curve will be automatically re-evaluated
points_b = crv.evalpts
``` |

### Inserting a knot¶

`insert_knot`

method is recommended for this purpose.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | ```
from geomdl import BSpline
# Create the curve instance
crv = BSpline.Curve()
# Set degree
crv.degree = 2
# Set control points
crv.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Set knot vector
crv.knotvector = [0, 0, 0, 1, 1, 1]
# Insert knot
crv.insert_knot(0.5)
``` |

### Plotting¶

To plot the curve, a visualization module should be imported and curve should be updated to use the visualization module.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ```
from geomdl import BSpline
# Create the curve instance
crv = BSpline.Curve()
# Set degree
crv.degree = 2
# Set control points
crv.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Set knot vector
crv.knotvector = [0, 0, 0, 1, 1, 1]
# Import Matplotlib visualization module
from geomdl.visualization import VisMPL
# Set the visualization component of the curve
crv.vis = VisMPL.VisCurve3D()
# Plot the curve
crv.render()
``` |

### Convert non-rational to rational curve¶

The following code snippet generates a B-Spline (non-rational) curve and converts it into a NURBS (rational) curve.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | ```
from geomdl import BSpline
# Create the curve instance
crv = BSpline.Curve()
# Set degree
crv.degree = 2
# Set control points
crv.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Set knot vector
crv.knotvector = [0, 0, 0, 1, 1, 1]
# Import convert module
from geomdl import convert
# BSpline to NURBS
crv_rat = convert.bspline_to_nurbs(crv)
``` |

### Using knot vector generator¶

Knot vector generator is located in the knotvector module.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 | ```
from geomdl import BSpline
from geomdl import knotvector
# Create the curve instance
crv = BSpline.Curve()
# Set degree
crv.degree = 2
# Set control points
crv.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Generate a uniform knot vector
crv.knotvector = knotvector.generate(crv.degree, crv.ctrlpts_size)
``` |

### Plotting multiple curves¶

multi module can be used to plot multiple curves on the same figure.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | ```
from geomdl import BSpline
from geomdl import multi
from geomdl import knotvector
# Create the curve instance #1
crv1 = BSpline.Curve()
# Set degree
crv1.degree = 2
# Set control points
crv1.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]]
# Generate a uniform knot vector
crv1.knotvector = knotvector.generate(crv1.degree, crv1.ctrlpts_size)
# Create the curve instance #2
crv2 = BSpline.Curve()
# Set degree
crv2.degree = 3
# Set control points
crv2.ctrlpts = [[1, 0, 0], [1, 1, 0], [2, 1, 0], [1, 1, 0]]
# Generate a uniform knot vector
crv2.knotvector = knotvector.generate(crv2.degree, crv2.ctrlpts_size)
# Create a curve container
mcrv = multi.CurveContainer(crv1, crv2)
# Import Matplotlib visualization module
from geomdl.visualization import VisMPL
# Set the visualization component of the curve container
mcrv.vis = VisMPL.VisCurve3D()
# Plot the curves in the curve container
mcrv.render()
``` |

Please refer to the Examples Repository for more curve examples.

## Working with the surfaces¶

The majority of the surface API is very similar to the curve API. Since a surface is defined on a 2-dimensional
parametric space, the getters/setters have a suffix of `_u`

and `_v`

; such as `knotvector_u`

and
`knotvector_v`

.

For setting up the control points, please refer to the control points manager documentation.

Please refer to the Examples Repository for surface examples.

## Working with the volumes¶

Volumes are defined on a 3-dimensional parametric space. Working with the volumes are very similar to working
with the surfaces. The only difference is the 3rd parametric dimension, `w`

. For instance, to access the
knot vectors, the properties you will use are `knotvector_u`

, `knotvector_v`

and `knotvector_w`

.

For setting up the control points, please refer to the control points manager documentation.

Please refer to the Examples Repository for volume examples.