In most situations we will start with already existing geometry and transform it into new geometries. Such is the usual method to create curves from lines that we will now learn.

This approach is similar to the standard way of dealing with curves and surfaces in differential geometry: One starts with a parameter domain $M$ which could be a subset of $\mathbb{R}^n$ or just an abstract $n$-dimensional manifold. For concreteness, just imagine that $n$ is either one (for the study of curves) or two (for surfaces). The geometric objects of interest are then certain smooth maps $f:M \to \mathbb{R}^3$. Such an $f$ is then called a parametrized curve (in case $n=1$) or a parametrized surface (if $n=2$).

If $M$ is a compact connected one-dimensional manifold with non-empty boundary we can as well assume that $M$ is a closed interval $[a,b]$ on the real line:

### Open Curves

In Houdini a discrete version of the interval $[a,b]$ can conveniently supplied by a `Grid`

node where the `Rows`

has been set to one. The `Columns`

parameter specifies the number of equally spaced sample points on interval. Instead of specifying $a,b$ directly we have to provide $b-a$ as the first component of the `Size`

parameter and $(a+b)/2$ as the first component of the `Center`

parameter. Afterwards we use a node of type `Point Wrangle`

in order to map the $x$-coordinate to the desired space curve.

The curve in the last picture results from the VEX code below. `alpha`

, `omega`

and `lambda`

are three float parameters of that `Point Wrangle`

node.

1 2 3 4 5 6 7 8 9 10 11 12 13 |
#include "Math.h" float alpha = PI/180 * ch("alpha"); float omega = ch("omega"); float lambda = ch("lambda"); float t = @P.x; float c = cos(alpha); float s = sin(alpha); float r = exp(lambda * t); @P.z = r * s * cos(omega * t); @P.x = r * s * sin(omega * t); @P.y = r * c; |

##### Guided Example: Open Curve

Lets see in detail how we archived this. First create a **grid node** (we named it domain_grid) and adjust its size to 1,1 and the number of rows to 1 and the number of columns to however many points you want.

Now we have a curve that is **just on the x-axis** with values from -1 to 1, meaning that * @P.x *is the carrier of the running parameter and the only thing we care about. We can transform these values from the [-1,1] to the [0,1] interval using a point wrangler with the following code.

1 2 |
//scale domain to [0,1] @P.x = @P.x*2-1; |

Next we will add another point wrangler to take the @P.x values and use them in our function to map them.

1 2 3 4 5 6 7 8 |
// compute the curve float t = @P.x; float r = 1*t; float a = t*$PI*2*3; // parametrize @P.x=r*cos(a)/2; @P.y=r*sin(a); @P.z=t+.5; |

Of course we advise to bring in the style nodes from previous tutorials.

###### Optional:

You can also add the **@*** Time to @P.x *in order to move along the parameter axis. We do this in the scale_x node.

1 2 3 |
//scale domain to [0,1] // we additionally animate the curve for fun @P.x = @P.x*2-1+ @Time/360*100; |

#### Closed Curves

If $M$ is a compact connected one-dimensional manifold without boundary then we can as well assume that $M$ is the unit circle $S^1\subset \mathbb{R}^2$:

In Houdini a discrete version of the unit circle $S^1$ can conveniently be supplied by a ** Circle node** where the

`Primitive Type`

has been set to `Polygon`

. The `Divisions`

parameter specifies the number of equally spaced sample points on the circle. Afterwards we use a node of type **in order to map the$(x,y)$-coordinates on the circle to the desired space curve. The curve in the last picture results from the VEX code below.**

`Point Wrangle`

`k`

is an integer parameter and `r`

a float parameter of that `Point Wrangle`

node.
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 |
#include "math.h" #include "$HIP/include/Complex.h" // we have written Complex.h our self. // It is located in the directior "include" next // to the Houdini file we are currently working with. // create parameters of our special arc-length curve float k = 5; float r = 1; float q = pow(r,2*k-1); float m = 2*k-1; float a = 1/(2*k-1); float b = 2*pow(r,k)/k; float fac = 1/(r+q); // read coordinates float c = @P.x; float s = @P.y; // interprete as complex number and take complex exponents vector2 zm = cpow(set(c,s),(int)m); vector2 zk = cpow(set(c,s),(int)k); // parametrize the curve @P.x = fac*(r*c + a*q*zm.x); @P.y = fac*b*zk.y; @P.z = fac*(r*s - a*q*zm.y); |

We have used here an include file “*Complex.h” *which implements some complex arithmetic function definitions. We discuss this in detail in the tutorial on Custom Code.

Note that the sample points on the space curve roughly look equally spaced. The reason is that in this particular example the corresponding smooth curve is parametrized by arclength for all values of the parameters $k,r$. This means that if $p$ runs through the unit circle with unit speed then also $\gamma(s)$ travels with unit speed.

##### Guided Example: Closed Curve

Open up your circle node and set the parameters as shown in the gif. Make sure that the Primitive Type is set to Polygon.

Continue by implementing two point wranglers with the VEX code below. The **Time_Motion **node is optional and implemented to show the closed nature of the curve.

1 2 3 4 5 6 7 8 |
// read coordinates float c = @P.x; float s = @P.y; // read time float t = @Time/2; // parameterize with a time rotation @P.x = cos(t)*c +sin(t)*s; @P.y = -sin(t)*c +cos(t)*s; |

1 2 3 4 5 |
// here we transform our points on the circle to have // desired closed curve shape. float c = @P.x; float s = @P.y; @P.z = 0.1*sin(10*atan2(s,c)); |

Here we used **atan2(s,c)** in order to get the angle of the point in the circle.

Don’t be surprised if your resulting object is still not a curve. You will still only have a deformed circle. In order to make the function pretty again you need to insert the wire frame and spheres at least. **Tip:** always try to keep the nodes as organized as possible.

**Optional note:** By inserting a **remesh **node you can make use of the whole geometry. This might become handy if you need a triangulation of a disc.