Cfrgtkky

without a grid

documentclass{minimal}

usepackage{pst-solides3d}

pagestyle{empty}

begin{document}



begin{pspicture}(-6,-4)(6,4)

psset{viewpoint=30 0 15 rtp2xyz,Decran=30,lightsrc=viewpoint}

psSolid[object=tore,r1=5,r0=1,ngrid=36 72,fillcolor=blue!30,grid=false]%

end{pspicture}



end{document}

with a grid and colors

documentclass{article}

usepackage{pst-solides3d}

begin{document}



begin{pspicture}(-3,-4)(3,6)

psset{Decran=30,viewpoint=20 40 30 rtp2xyz,lightsrc=viewpoint}

 psSolid[object=tore,r1=2.5,r0=1.5,ngrid=18 36,fillcolor=green!30]%

end{pspicture}



begin{pspicture}(-3,-4)(3,6)

psset{Decran=30,viewpoint=20 40 30 rtp2xyz,lightsrc=viewpoint}

 psSolid[object=tore,r1=2.5,r0=1.5,ngrid=18 36,

  tablez=0 0.3 1.5 { } for, zcolor=1 0 0 0 1 1]%

end{pspicture}



end{document}

You could parametrize the surface as (for example)

x(t,s) = (2+cos(t))*cos(s+pi/2) 

y(t,s) = (2+cos(t))*sin(s+pi/2) 

z(t,s) = sin(t)

where both t and s take values on [0,2pi] and then use the pgfplots package.

Admittedly, I'm not sure if this package was available at the time when the question was written :)

documentclass{article}

usepackage{pgfplots}



begin{document}



begin{tikzpicture}

    begin{axis}

       addplot3[surf,

       colormap/cool,

       samples=20,

       domain=0:2*pi,y domain=0:2*pi,

       z buffer=sort]

       ({(2+cos(deg(x)))*cos(deg(y+pi/2))}, 

        {(2+cos(deg(x)))*sin(deg(y+pi/2))}, 

        {sin(deg(x))});

    end{axis}

end{tikzpicture}



end{document}

Or else with PSTricks

documentclass{article}

usepackage{pst-solides3d}

begin{document}



begin{pspicture}(-3,-4)(3,6)

psset{viewpoint=20 40 40 rtp2xyz,Decran=30,lightsrc=20 10 10}

defFunction[algebraic]{torus}(u,v)

  {(2+cos(u))*cos(v+Pi)}

  {(2+cos(u))*sin(v+Pi)}

  {sin(u)}  

psSolid[object=surfaceparametree,

         base=-10 10 0 6.28,fillcolor=black!70,incolor=orange,

         function=torus,ngrid=60 0.4,

         opacity=0.25]

end{pspicture}



end{document}

Anthony Phan wrote a 3d extension of Metapost, m3D, which is well suited to such things. As an example, he wrote some code to draw a graph on a Torus (last example):

The downside is that this fork doesn't support nice things like the mptosvg SVG converter, &c, nor the nice Metapost 2 extensions. I seem to recall some discussion of adding 3d support to the mainstream (i.e. Taco Hoekwater stream) Metapost, but I guess that didn't come to anything. But there is some fairly well established 3d drawing support for the regular Metapost language by Dennis Riegel.

Here's a solution using an Asymptote module I am writing (which is still in its very early stages).

The images:

A vector image of the contour:

or, "just for fun," in a gif animation (my first ever):

Note that, by design, this animation pauses momentarily when it is the same image (up to resolution) as the one above.

The code:

First, save the following code in a file called surfacepaths.asy:

import graph3;

import contour;



// A bunch of auxiliary functions.



real fuzz = .001;



real umin(surface s) { return 0; }

real vmin(surface s) { return 0; }

pair uvmin(surface s) { return (umin(s), vmin(s)); }

real umax(surface s, real fuzz=fuzz) {

  if (s.ucyclic()) return s.index.length;

  else return s.index.length - fuzz;

}

real vmax(surface s, real fuzz=fuzz) {

  if (s.vcyclic()) return s.index[0].length;

  return s.index[0].length - fuzz;

}

pair uvmax(surface s, real fuzz=fuzz) { return (umax(s,fuzz), vmax(s,fuzz)); }



typedef real function(real, real);



function normalDot(surface s, triple eyedir(triple)) {

  real toreturn(real u, real v) {

    return dot(s.normal(u, v), eyedir(s.point(u,v)));

  }

  return toreturn;

}



struct patchWithCoords {

  patch p;

  real u;

  real v;

  void operator init(patch p, real u, real v) {

    this.p = p;

    this.u = u;

    this.v = v;

  }

  void operator init(surface s, real u, real v) {

    int U=floor(u);

    int V=floor(v);

    int index = (s.index.length == 0 ? U+V : s.index[U][V]);



    this.p = s.s[index];

    this.u = u-U;

    this.v = v-V;

  }

  triple partialu() {

    return p.partialu(u,v);

  }

  triple partialv() {

    return p.partialv(u,v);

  }

}



typedef triple paramsurface(pair);



paramsurface tangentplane(surface s, pair pt) {

  patchWithCoords thepatch = patchWithCoords(s, pt.x, pt.y);

  triple partialu = thepatch.partialu();

  triple partialv = thepatch.partialv();

  return new triple(pair tangentvector) {

    return s.point(pt.x, pt.y) + (tangentvector.x * partialu) + (tangentvector.y * partialv);

  };

}



guide normalpathuv(surface s, projection P = currentprojection, int n = ngraph) {

  triple eyedir(triple a);

  if (P.infinity) eyedir = new triple(triple) { return P.camera; };

  else eyedir = new triple(triple pt) { return P.camera - pt; };

  return contour(normalDot(s, eyedir), uvmin(s), uvmax(s), new real {0}, nx=n)[0];

}



path3 onSurface(surface s, path p) {

  triple f(int t) {

    pair point = point(p,t);

    return s.point(point.x, point.y);

  }



  guide3 toreturn = f(0);

  paramsurface thetangentplane = tangentplane(s, point(p,0));

  triple oldcontrol, newcontrol;

  int size = length(p);

  for (int i = 1; i <= size; ++i) {

    oldcontrol = thetangentplane(postcontrol(p,i-1) - point(p,i-1));

    thetangentplane = tangentplane(s, point(p,i));

    newcontrol = thetangentplane(precontrol(p, i) - point(p,i));

    toreturn = toreturn .. controls oldcontrol and newcontrol .. f(i);

  }



  if (cyclic(p)) toreturn = toreturn & cycle;



  return toreturn;



}



/*

 * This method returns an array of paths that trace out all the

 * points on s at which s is parallel to eyedir.

 */



path paramSilhouetteNoEdges(surface s, projection P = currentprojection, int n = ngraph) {

   guide uvpaths = normalpathuv(s, P, n);

  //Reduce the number of segments to conserve memory

  for (int i = 0; i < uvpaths.length; ++i) {

    real len = length(uvpaths[i]);

    uvpaths[i] = graph(new pair(real t) {return point(uvpaths[i],t);}, 0, len, n=n);

  }

  return uvpaths;

}   



private typedef real function2(real, real);

private typedef real function3(triple);



triple normalVectors(triple dir, triple surfacen) {

  dir = unit(dir);

  surfacen = unit(surfacen);

  triple v1, v2;

  int i = 0;

  do {

    v1 = unit(cross(dir, (unitrand(), unitrand(), unitrand())));

    v2 = unit(cross(dir, (unitrand(), unitrand(), unitrand())));

    ++i;

  } while ((abs(dot(v1,v2)) > Cos(10) || abs(dot(v1,surfacen)) > Cos(5) || abs(dot(v2,surfacen)) > Cos(5)) && i < 1000);

  if (i >= 1000) {

    write("problem: Unable to comply.");

    write(" dir = " + (string)dir);

    write(" surface normal = " + (string)surfacen);

  }

  return new triple {v1, v2};

}



function3 planeEqn(triple pt, triple normal) {

  return new real(triple r) {

    return dot(normal, r - pt);

  };

}



function2 pullback(function3 eqn, surface s) {

  return new real(real u, real v) {

    return eqn(s.point(u,v));

  };

}



/*

 * returns the distinct points in which the surface intersects

 * the line through the point pt in the direction dir

 */



triple intersectionPoints(surface s, pair parampt, triple dir) {

  triple pt = s.point(parampt.x, parampt.y);

  triple lineNormals = normalVectors(dir, s.normal(parampt.x, parampt.y));

  path curves;

  for (triple n : lineNormals) {

    function3 planeEn = planeEqn(pt, n);

    function2 pullback = pullback(planeEn, s);

    guide contour = contour(pullback, uvmin(s), uvmax(s), new real{0})[0];



    curves.push(contour);

  }

  pair intersectionPoints;

  for (path c1 : curves[0])

    for (path c2 : curves[1])

      intersectionPoints.append(intersectionpoints(c1, c2));

  triple toreturn;

  for (pair P : intersectionPoints)

    toreturn.push(s.point(P.x, P.y));

  return toreturn;

}







/*

 * Returns those intersection points for which the vector from pt forms an

 * acute angle with dir.

 */

 int numPointsInDirection(surface s, pair parampt, triple dir, real fuzz=.05) {

  triple pt = s.point(parampt.x, parampt.y);

  dir = unit(dir);

  triple intersections = intersectionPoints(s, parampt, dir);

  int num = 0;

  for (triple isection: intersections)

    if (dot(isection - pt, dir) > fuzz) ++num;

  return num;

}



bool3 increasing(real t0, real t1) {

  if (t0 < t1) return true;

  if (t0 > t1) return false;

  return default;

}



int extremes(real f, bool cyclic = f.cyclic) {

  bool3 lastIncreasing;

  bool3 nextIncreasing;

  int max;

  if (cyclic) {

    lastIncreasing = increasing(f[-1], f[0]);

    max = f.length - 1;

  } else {

    max = f.length - 2;

    if (increasing(f[0], f[1])) lastIncreasing = false;

    else lastIncreasing = true;

  }

  int toreturn;

  for (int i = 0; i <= max; ++i) {

    nextIncreasing = increasing(f[i], f[i+1]);

    if (lastIncreasing != nextIncreasing) {

      toreturn.push(i);

    }

    lastIncreasing = nextIncreasing;

  }

  if (!cyclic) toreturn.push(f.length - 1);

  toreturn.cyclic = cyclic;

  return toreturn;

}



int extremes(path path, real f(pair) = new real(pair P) {return P.x;})

{

  real fvalues = new real[size(path)];

  for (int i = 0; i < fvalues.length; ++i) {

    fvalues[i] = f(point(path, i));

  }

  fvalues.cyclic = cyclic(path);

  int toreturn = extremes(fvalues);

  fvalues.delete();

  return toreturn;

}



path splitAtExtremes(path path, real f(pair) = new real(pair P) {return P.x;})

{

  int splittingTimes = extremes(path, f);

  path toreturn;

  if (cyclic(path)) toreturn.push(subpath(path, splittingTimes[-1], splittingTimes[0]));

  for (int i = 0; i+1 < splittingTimes.length; ++i) {

    toreturn.push(subpath(path, splittingTimes[i], splittingTimes[i+1]));

  }

  return toreturn;

}



path splitAtExtremes(path paths, real f(pair P) = new real(pair P) {return P.x;})

{

  path toreturn;

  for (path path : paths) {

    toreturn.append(splitAtExtremes(path, f));

  }

  return toreturn;

}



path3 toCamera(triple p, projection P=currentprojection, real fuzz = .01, real upperLimit = 100) {

  if (!P.infinity) {

    triple directionToCamera = unit(P.camera - p);

    triple startingPoint = p + fuzz*directionToCamera;

    return startingPoint -- P.camera;

  }

  else {

    triple directionToCamera = unit(P.camera);

    triple startingPoint = p + fuzz*directionToCamera;



    return startingPoint -- (p + upperLimit*directionToCamera);

  }

}



int numSheetsHiding(surface s, pair parampt, projection P = currentprojection) {

  triple p = s.point(parampt.x, parampt.y);

  path3 tocamera = toCamera(p, P);

  triple pt = beginpoint(tocamera);

  triple dir = endpoint(tocamera) - pt;

  return numPointsInDirection(s, parampt, dir);

}



struct coloredPath {

  path path;

  pen pen;

  void operator init(path path, pen p=currentpen) {

    this.path = path;

    this.pen = p;

  }

  /* draws the path with the pen having the specified weight (using colors)*/

  void draw(real weight) {

    draw(path, p=weight*pen + (1-weight)*white);

  }

}

coloredPath layeredPaths;

// onTop indicates whether the path should be added at the top or bottom of the specified layer

void addPath(path path, pen p=currentpen, int layer, bool onTop=true) {

  coloredPath toAdd = coloredPath(path, p);

  if (layer >= layeredPaths.length) {

    layeredPaths[layer] = new coloredPath {toAdd};

  } else if (onTop) {

    layeredPaths[layer].push(toAdd);

  } else layeredPaths[layer].insert(0, toAdd);

}



void drawLayeredPaths() {

  for (int layer = layeredPaths.length - 1; layer >= 0; --layer) {

    real layerfactor = (1/3)^layer;

    for (coloredPath toDraw : layeredPaths[layer]) {

      toDraw.draw(layerfactor);

    }

  }

  layeredPaths.delete();

}



real cutTimes(path tocut, path knives) {

  real intersectionTimes = new real {0, length(tocut)};

  for (path knife : knives) {

    real complexIntersections = intersections(tocut, knife);

    for (real times : complexIntersections) {

      intersectionTimes.push(times[0]);

    }

  }

  return sort(intersectionTimes);

}



path cut(path tocut, path knives) {

  real cutTimes = cutTimes(tocut, knives);

  path toreturn;

  for (int i = 0; i + 1 < cutTimes.length; ++i) {

    toreturn.push(subpath(tocut,cutTimes[i], cutTimes[i+1]));

  }

  return toreturn;

}



real condense(real values, real fuzz=.001) {

  values = sort(values);

  values.push(infinity);

  real previous = -infinity;

  real lastMin;

  real toReturn;

  for (real t : values) {

    if (t - fuzz > previous) {

      if (previous > -infinity) toReturn.push((lastMin + previous) / 2);

      lastMin = t;

    }

    previous = t;

  }

  return toReturn;

}



/*

 * A smooth surface parametrized by the domain [0,1] x [0,1]

 */

struct SmoothSurface {

  surface s;

  private real sumax;

  private real svmax;

  path paramSilhouette;

  path projectedSilhouette;

  projection theProjection;



  path3 onSurface(path paramPath) {

    return onSurface(s, scale(sumax,svmax)*paramPath);

  }



  triple point(real u, real v) { return s.point(sumax*u, svmax*v); }

  triple point(pair uv) { return point(uv.x, uv.y); }

  triple normal(real u, real v) { return s.normal(sumax*u, svmax*v); }

  triple normal(pair uv) { return normal(uv.x, uv.y); }



  void operator init(surface s, projection P=currentprojection) {

    this.s = s;

    this.sumax = umax(s);

    this.svmax = vmax(s);

    this.theProjection = P;

    this.paramSilhouette = scale(1/sumax, 1/svmax) * paramSilhouetteNoEdges(s,P);

    this.projectedSilhouette = sequence(new path(int i) {

    path3 truePath = onSurface(paramSilhouette[i]);

    path projectedPath = project(truePath, theProjection, ninterpolate=1);

    return projectedPath;

      }, paramSilhouette.length);

  }



  int numSheetsHiding(pair parampt) {

    return numSheetsHiding(s, scale(sumax,svmax)*parampt);

  }



  void drawSilhouette(pen p=currentpen, bool includePathsBehind=false, bool onTop = true) {

    int extremes;

    for (path path : projectedSilhouette) {

      extremes.push(extremes(path));

    }



    path splitSilhouette;

    path paramSplitSilhouette;



    /*

     * First, split at extremes to ensure that there are no

     * self-intersections of any one subpath in the projected silhouette.

     */



    for (int j = 0; j < paramSilhouette.length; ++j) {

      path current = projectedSilhouette[j];



      path currentParam = paramSilhouette[j];



      int dividers = extremes[j];

      for (int i = 0; i + 1 < dividers.length; ++i) {

    int start = dividers[i];

    int end = dividers[i+1];

    splitSilhouette.push(subpath(current,start,end));

    paramSplitSilhouette.push(subpath(currentParam, start, end));

      }

    }



    /*

     * Now, split at intersections of distinct subpaths.

     */



    for (int j = 0; j < splitSilhouette.length; ++j) {

      path current = splitSilhouette[j];

      path currentParam = paramSplitSilhouette[j];



      real splittingTimes = new real {0,length(current)};

      for (int k = 0; k < splitSilhouette.length; ++k) {

    if (j == k) continue;

    real times = intersections(current, splitSilhouette[k]);

    for (real time : times) {

      real relevantTime = time[0];

      if (.01 < relevantTime && relevantTime < length(current) - .01) splittingTimes.push(relevantTime);

    }

      }

      splittingTimes = sort(splittingTimes);

      for (int i = 0; i + 1 < splittingTimes.length; ++i) {

    real start = splittingTimes[i];

    real end = splittingTimes[i+1];

    real mid = start + ((end-start) / (2+0.1*unitrand()));

    pair theparampoint = point(currentParam, mid);

    int sheets = numSheetsHiding(theparampoint);



    if (sheets == 0 || includePathsBehind) {

      path currentSubpath = subpath(current, start, end);

      addPath(currentSubpath, p=p, onTop=onTop, layer=sheets);

    }



      }

    }

  }



  /*

    Splits a parametrized path along the parametrized silhouette,

    taking [0,1] x [0,1] as the

    fundamental domain.  Could be implemented more efficiently.

  */

  private real splitTimes(path thepath) {

    pair min = min(thepath);

    pair max = max(thepath);

    path baseknives = paramSilhouette;

    path knives;

    for (int u = floor(min.x); u < max.x + .001; ++u) {

      for (int v = floor(min.y); v < max.y + .001; ++v) {

    knives.append(shift(u,v)*baseknives);

      }

    }

    return cutTimes(thepath, knives);

  }



  /*

    Returns the times at which the projection of the given path3 intersects

    the projection of the surface silhouette. This may miss unstable

    intersections that can be detected by the previous method.

  */

  private real silhouetteCrossingTimes(path3 thepath, real fuzz = .01) {

    path projectedpath = project(thepath, theProjection, ninterpolate=1);

    real crossingTimes = cutTimes(projectedpath, projectedSilhouette);

    if (crossingTimes.length == 0) return crossingTimes;

    real current = 0;

    real toReturn = new real {0};

    for (real prospective : crossingTimes) {

      if (prospective > current + fuzz

      && prospective < length(thepath) - fuzz) {

    toReturn.push(prospective);

    current = prospective;

      }

    }

    toReturn.push(length(thepath));

    return toReturn;

  }



  void drawSurfacePath(path parampath, pen p=currentpen, bool onTop=true) {

    path toDraw;

    real crossingTimes = splitTimes(parampath);

    crossingTimes.append(silhouetteCrossingTimes(onSurface(parampath)));

    crossingTimes = condense(crossingTimes);

    for (int i = 0; i+1 < crossingTimes.length; ++i) {

      toDraw.push(subpath(parampath, crossingTimes[i], crossingTimes[i+1]));

    }

    for (path thepath : toDraw) {

      pair midpoint = point(thepath, length(thepath) / (2+.1*unitrand()));

      int sheets = numSheetsHiding(midpoint);

      path path3d = project(onSurface(thepath), theProjection, ninterpolate = 1);

      addPath(path3d, p=p, onTop=onTop, layer=sheets);

    }

  }

}



SmoothSurface operator *(transform3 t, SmoothSurface s) {

  return SmoothSurface(t*s.s);

}

To get the clean image, compile the following tex file as described in the comments. (The tex file should be in the same directory as surfacepaths.asy.)

%usage (if file is named foo.tex):

%> pdflatex foo.tex

%> asy foo-*.asy

%> pdflatex foo.tex

documentclass[margin=10pt]{standalone}

usepackage{asymptote}

begin{document}

begin{asy}

import surfacepaths;

size(10cm,0);

int niceangle = 70;

currentprojection = orthographic(camera=10Z + .1Y, up=Y);

surface torus = surface(Circle(c=2Y,normal=X,r=0.5,n=32), c=O, axis=Z, n=32);

SmoothSurface Torus = SmoothSurface(rotate(angle=-niceangle, v=X) * torus);

Torus.drawSilhouette();

drawLayeredPaths();

end{asy}

end{document}

To get the animated version (as a gif file), run the following Asymptote code. (For instance, save it in the file foo.asy, and then enter asy foo at the command line.)

import surfacepaths;

import animation;



size(50cm,0);    // Increased size and line width for better resolution



int niceangle = 70;



currentprojection = orthographic(camera=10Z + .1Y, up=Y);

surface torus = surface(Circle(c=2Y,normal=X,r=0.5,n=100), c=O, axis=Z, n=32);

SmoothSurface Torus = SmoothSurface(rotate(angle=-niceangle, v=X) * torus);



animation A;



for (int angle = 0; angle <= 180; angle += 5) {

  save();

  (rotate(angle=-angle, v=X) * Torus).drawSilhouette(linewidth(2pt));    // Increase size and line width for better resolution

  drawLayeredPaths();

  A.add();

  restore();

  write("computed angle " + (string)angle);  //output some progress indicator

}



A.movie(delay=100);

I traced the original image to get the critical points. By setting showgrid to top and commenting out %rput(0,0){useboxIBox}, you can edit the critical points to get a better result that suits your preferences.

documentclass[pstricks,border=0pt]{standalone}

usepackage{pstricks-add}

usepackage{graphicx}



defColumns{10}

defRows{10}

newsaveboxIBox

saveboxIBox{includegraphics{torus.eps}}



psset

{

    xunit=0.5dimexprwdIBox/Columns,

    yunit=0.5dimexprhtIBox/Rows,

}



begin{document}

begin{pspicture}[showgrid=false](-Columns,-Rows)(Columns,Rows)

    %rput(0,0){useboxIBox}

    psellipse(9.7,9)

    deftemp{%

    psbezier(0,3.3)(3,3.3)(5,2)(5.4,1.2)

    psbezier(0,-0.5)(3,-0.5)(5,0.5)(5.4,1.2)

    psbezier[linewidth=0.5pslinewidth,linecolor=lightgray](5.4,1.2)(5.7,1.5)(6.2,2.9)(7.5,3.3)    

    pscurve(5.4,1.2)(5.55,1.42)(6.0,2.1)}%

    temppsscalebox{-1 1}{temp}

end{pspicture}

end{document}

The following is the output:

And the original one:

Along the line of @AndrewStacey, I tried something slightly simpler. Using one ellipse and an two elliptical arcs, translated, I get the (almost) right visual effect, which is not at all accurate:

The code is rather simple and easy to tweak in case one wants to get a better/different visual effect:

documentclass[tikz,border=5pt]{standalone}

begin{document}

begin{tikzpicture}[samples=100]

  defa{3.2}

  defb{1.5}

  defPI{3.14159265359}

  draw[domain=0:2*PI] plot ({a*cos(x r)},{b*sin(x r)});

  draw[domain=PI/4:3*PI/4] plot ({a*cos(x r)},{b*sin(x r) -1});

  draw[domain=-0.1+5*PI/4:0.1+7*PI/4] plot ({a*cos(x r)},{b*sin(x r) +1.1});

end{tikzpicture}

end{document}

This is a pretty old question, but I thought I might as well add my solution, which I think looks pretty good and doesn't require any complicated calculations:

begin{tikzpicture}

  useasboundingbox (-3,-1.5) rectangle (3,1.5);

  draw (0,0) ellipse (3 and 1.5);

  begin{scope}

    clip (0,-1.8) ellipse (3 and 2.5);

    draw (0,2.2) ellipse (3 and 2.5);

  end{scope}

  begin{scope}

    clip (0,2.2) ellipse (3 and 2.5);

    draw (0,-2.2) ellipse (3 and 2.5);

  end{scope}

end{tikzpicture}

Here's a quick and dirty way to draw a thin ring (I used this for a ring of wire in a physics problem).

documentclass{minimal}

usepackage{tikz}

begin{document}

tikz{

   % outer ellipse filled with gray:

  draw [black, fill=gray!50](0,0) circle (2.05cm and 0.55cm);

   % inner ellipse, filled with white, a bit higher and smaller:

 draw [black, fill=white](0,.04) circle (1.95cm and 0.45cm);

  }

end{document}