New Stuff

User functions with parameters

  #declare Gravity_Well =
     function(x,y,z,Strength) {
         x*x -Strength/y*y +z*z
     }

  isosurface {
    function { Gravity_Well(x, y, z, 0.002) }

#declare S = function {
   spline {
     linear_spline
    -1.0, < 0.5, 0, 0>,
    -0.5, < 0,   0, 0>,
     0.01,< 0.2, 0, 0>,
     0.5, <-0.2, 0, 0>,
     1, <-0.2, 0, 0>
   }
 }

isosurface {
  function { y - S(x).x }

Spline Functions

In this case I'm using the first column of the spline only. As x goes from -1 to +1 S(x) goes from <0.5,0,0> to <-0.2,0,0> along the spline.
For an isosurface, we don't want a vector function, so we choose the S(x).x component of the function.

We can see that the isosurface follows the x co-ordinate of the spline, which is shown in red in the attached image.

Warning: There are known bugs in spline functions in POV 3.5b1. For example, if we replace the 0.01 point in the above example by

    0.0, < 0.2, 0, 0>,

#declare S = function {
   spline {
     natural_spline
      -1, < 0.5, 0, 0.0>,
    -0.5, < 0.2, 0, 0.4>,
    0.01, < 0.2, 0, 0.2>,
     0.5, < 0.4, 0, 0.4>,
       1, < 0.0, 0,-0.6>
   }
 }

isosurface {
  function { y - S(x).x - S(z).z }

Here's a natural spline function. We can see that the surface follows both the x and z co-ordinates of the spline, which are shown in red and green respectively in the attached image.

In this way, it's possible to generate a 3d isosurface sheet from two 2d splines.

The new POV 3.5 "cubic_spline" is not very suitable for isosurface work because it can be undefined at the endpoints, which causes strange effects in the surface.

#declare S = function {
   spline {
     natural_spline
      -1, < 0, 0.5, 0.0>,
    -0.5, < 0, 0.2, 0.4>,
    0.01, < 0, 0.2, 0.2>,
     0.5, < 0, 0.4, 0.4>,
       1, < 0, 0.0,-0.6>
   }
 }

isosurface {
  function { pow(y - S(x).y),2) 
       + pow(z - S(x).z,2) - 0.05 }

It's also possible to write it in a way that more clearly separates the "hoop" function from the spline function, making it easier to replace the circular hoop with some other shape.

#declare Hoop = function(x,y,z,r){y*y + z*z - r*r}

isosurface {
  function {Hoop(x, y-S(x).y, z-S(x).z, 0.223)}

In the lower image I've added a ripple to the isosurface, so now you can drape intestines along a 3d spline path.

parametric {
  function {S(u).x + sin(v)}
  function {S(u).y + cos(v)}
  function {S(u).z}
    <0,-pi><17,pi>
  contained_by{box
     {min_extent(The_Path)-<1,1,0.1>
      max_extent(The_Path)+<1,1,0.1>}
     }

The way to follow 3d splines that contain loops is to use all three of the spline dimensions to specify the path of the spline, and express x, y, and z in terms of a fourth variable, call it "u", which follows the control points.

So what we need is a parametric isosurface.

In this case "u" follows the spline control points, and x, y, z are expressed in terms of u like S(u).x, S(u).y, S(u).z. On its own that would give an infinitely thin string that follows the spline path. We can fatten it out by adding some terms in a second variable "v" which describe how far the surface is from the path.

Once again I have made the isosurface transparent and drawn the actual spline path inside it in yellow.

For this image, I didn't know how large to make the contained_by box, so I've calculated it during the parsing of the scene by taking the min_extent() and max_extent() vectors of the yellow spline path and added something to allow for the thickness of the wrapping.

It's not actually an isosurface at all, but a mesh. I just stuck it here since it's doing a similar job to some of the isosurface examples on this page.