I didn't have as much time as I would have liked to explore this,
but after fiddling with the Dupin cyclide in both isosurface (implicit) and
parametric form, I found the parameters to be highly unintuitive, the desired
shape very difficult to achieve and control, and the constraints on the
parameters too complex to be easily implemented.

I hadn't gotten around to unraveling the implicit equation to fit the syntax for
a polynomial.

So I home-cooked a formula for the minor radius of a torus, and patched that
into the code I had for a normal parametric torus, and it gives me the desired
shape with only 3 values required.

It is, however, SLLLLllllllllllooooooooooowwwwwwww.
Which is to be expected for a parametric, but probably with Ingo's slick method,
it will be fast enough to do what I want.

See how the toroid (left) has a variable minor radius, and when rotated around
the x axis appears to be equally wide along both front and back.
The radii, position, and camera placement were all chosen to get that to work
out.

Further work ought to yield a torus with a user-supplied major radius, which
when placed at any distance from the camera will automatically calculate the
proper radii for the fore and aft sections so as to be _just_ visible (1 pixel
wide or high)

// Dupin cylide and Faux-Dupin-cyclide object
// Bald Eagle 2017-05
#version 3.7;
global_settings {
 assumed_gamma 1.0
}
#include "colors.inc"
#declare Location = <0, 0, -10>;
#declare LookAt = <0, 0, 0>;
camera {
 location  Location
 right     x*image_width/image_height
 look_at   LookAt
}
sky_sphere {pigment {White*0}}
light_source {<0, 10, -50> color White}



#declare Method = 2;
#switch (Method)

#case (0)
// Dupin Cyclide with isosurface
#declare a = 3;
#declare b = 1;
#declare c = sqrt (a*a - b*b);
#debug concat ( " c = ", str (c, 3, 3),  "\n")
#declare d = 2;

// c < d < a

isosurface {
 function {pow(x*x + y*y + z*z + b*b - d*d, 2) - 4*pow(a*x - c*d, 2) -
4*(b*b*y*y)}

 threshold 0
 accuracy 0.0001
 max_gradient 3000
 contained_by {box {<-10, -10, -10>, <10, 10, 10>}}

 texture {
  pigment {color rgb <0.3, 1.0, 0.1>}
  finish {phong 1}
 }


} // end isosurface
#break

#case (1)
// Dupin Cyclide with parametric
#declare a = 4;
#declare b = 1;
#declare c = sqrt (a*a - b*b);
#debug concat ( " c = ", str (c, 3, 3),  "\n")
#declare d = 3.9;

// c < d < a

parametric {
 function { ( d*(c-a*cos(u)*cos(v)) + (b*b*cos(u)) ) / ( a-c*cos(u)*cos(v) ) },
// x-axis
 function { ( b*sin(u)*(a-d*cos(v)) ) / ( a-c*cos(u)*cos(v) )  },   // y-axis
 function { ( (b*sin(v))*(c*cos(u)-d) ) / (a-c*cos(u)*cos(v)) }             //
z-axis
 <0, 0>, <2*pi, 2*pi>
 //contained_by { sphere { 0,1 } } // texturing problem, use box instead to see!
 contained_by { box { <-20, -10, -10>, <10, 10, 10> } }
 // max_gradient 2
 accuracy 0.005        // 0.001 default, lower slower but better
 precompute 15 x,y,z   // precompute [x,y,z] normally gives faster rendering
(<=20)

 //rotate 180*x
 scale 1
 texture {pigment {color rgb <1, 0, 0> } }
} // end parametric


#break

#case (2)
// Home cooked variable torus with parametric

// Normal Torus
// #declare X = function (T, P, R, r) { cos(T) * ( R + r*cos(P) ) }
// #declare Y = function (T, P, R, r) { sin(T) * ( R + r*cos(P) ) }
// #declare Z = function (P, r)                      { r*sin(P) }

// So, the idea is that the minor radius circle that gets swept around the major
radius cirlce to form the torus varies from one radius to the other and then
back
// the average of the radii is (r1 + r2)/2, and then to get the large radius, we
add (r1 - r2)/2 and to get the smalll radius, we subtract (r1 - r2)/2
// as u varies, cosine u goes from 1 to 0, and then to -1 and back to 0 and then
1
// multiplying cosine u by (r1 - r2)/2 and adding to the average gives us a
varying minor radius - Max to average, and then average to min radius, and then
back to avg and max

// camera is at z = -10
// left variable torus shows varying minor radius
// major radius is 5
// when tilted back, and translated back 5 units, front of torus is at 0, rear
of torus is at -10, or absolute distances of 10 and 20 (double)
// far radius is double that of near radius, but when viewed at an extreme tilt,
they both have the same apparent width

#macro vtorus (Major, LargerMinor, SmallerMinor)

 #if (LargerMinor < SmallerMinor)
  #warning "Value expected for larger minor radius is less than smaller minor
radius. \n"
  #warning "Variable radius torus may not be in desired or expected orientation.
\n"
 #end // end check minor radius values
 #local MajorExtent = (Major + LargerMinor)*1.1;
 #local MinorExtent = LargerMinor*2;
 #local HalfSum = (LargerMinor + SmallerMinor)/2;
 #local HalfDifference = abs(LargerMinor - SmallerMinor)/2;

 #local VariableRadiusXY = function (u, v) {(Major + (HalfSum +
cos(u)*HalfDifference)*cos(v) )}
 #local VariableRadiusZ  = function (u, v) {(        (HalfSum +
cos(u)*HalfDifference)*sin(v) )}

 parametric {
  //function { cos(u) * (Major + (HalfSum + cos(u)*HalfDifference)*cos(v) ) },
// x-axis
  function { cos(u) * VariableRadiusXY (u, v) }, // x-axis
  function { sin(u) * VariableRadiusXY (u, v) },   // y-axis
  function { VariableRadiusZ (u, v) }             // z-axis
  <0, 0>, <2*pi, 2*pi> // <umin, vmin> to <umax, vmax>
  contained_by { box { <-MajorExtent, -MajorExtent, -MinorExtent>, <MajorExtent,
MajorExtent, MinorExtent> } }
  // max_gradient 2
  accuracy 0.01       // 0.001 default, lower slower but better
  precompute 15 x,y,z   // precompute [x,y,z] normally gives faster rendering
(<=20)
  texture {pigment {color rgb <1, 0, 0> } finish {specular 0.1}}
 }
#end // end macro vtorus


object {vtorus (5, 1, 0.5)
 rotate z*90
 translate -x*2.5
 translate z*5
}

object {vtorus (5, 0.5, 1)
 rotate z*90
 rotate x*80
 translate z*5
 translate x*2.5
}


#break

#else
// Do nothing
#end // end switch - case/range - break

Post a reply to this message

Attachments:
Download 'dupincyclide.png' (90 KB)

Preview of image 'dupincyclide.png'