I checked this post in here Drawing complex integration but what I want is draw the one that exclude zero and negative real numbers instead of positives. I tried to play around with the code in the link above and I couldn't figure it out. I'm a beginner with the drawings in Latex
[Tex/LaTex] Contour integrals
tikz-pgf
Related Solutions
OK, there is a lot going on here, but hopefully the comments go someway to making it clear how I've achieved this. I use a lot of nested style definitions, which possibly may make things tricky to follow but hopefully the style names give some indication of what they do. I also use a lot of nested \foreach loops for no other reason than I found it easier than using a matrix.
Some apologies in advance for mangling the German words in the style definitions.
\documentclass[border=5pt]{standalone}
\usepackage{tikz}
% pifont for tick and cross.
\usepackage{pifont}
% Only need the matrix library for delimiters.
\usetikzlibrary{matrix,fit}
\usetikzlibrary{shapes.geometric}
% Define some colors.
\colorlet{Klasse A}{red}
\colorlet{Klasse B}{blue}
\colorlet{probe color}{Klasse A}
\colorlet{correct color}{Klasse A}
\colorlet{incorrect color}{Klasse A}
\colorlet{testproben}{gray!20}
\def\vmark{}
\tikzset{
tight fit/.style={inner sep=0pt, outer sep=0pt},
probe color/.code={\colorlet{probe color}{#1}},
correct color/.code={\colorlet{correct color}{#1}},
incorrect color/.code={\colorlet{incorrect color}{#1}},
probe/.style args={#1-#2}{%
outer sep=0pt,
shape=rectangle,
probe #1-#2/.try,
execute at begin node={%
% Hide the testproben spike in a style rather than
% clutter up the main code.
\begin{tikzpicture}[x=2.75pt,y=1.5pt, scale=0.625]
\path [draw=probe color] plot [smooth] coordinates {(0,0)
(1,2) (2,10) (3,1) (4,3) (5,1) (6,4) (7,0)};
\end{tikzpicture}}
},
vorhesage/.style args={#1-#2}{
shape=circle,
draw=correct color,
text=white,
font=\bf\small,
vorhesage #1-#2/.try,
incorrect vorhesage #1-#2/.try,
minimum size=0.625cm
},
surrogat/.style={
shape=regular polygon,
regular polygon sides=3,
minimum height=1cm,
draw
}
}
\tikzset{
% The styles applied to specified testproben and (correct) vorhesage
testproben/.style args={#1-#2}{
probe #1-#2/.style={
fill=testproben
},
vorhesage #1-#2/.style={
fill=correct color,
execute at begin node=\def\vmark{\ding{51}}% A tick
}
},
% The styles applied to specified testproben and (incorrect) vorhesage
testproben */.style args={#1-#2}{
probe #1-#2/.style={
fill=testproben
},
incorrect vorhesage #1-#2/.style={
fill=incorrect color,
draw=correct color,
very thick,
execute at begin node=\def\vmark{\ding{55}}% A cross
}
},
Daten A/.style={
A/.try,
probe color=Klasse A,
},
Daten B/.style={
B/.try,
probe color=Klasse B,
shift={(5,0)}
},
Vorhesage A/.style={
A/.try,
correct color=Klasse A,
incorrect color=Klasse B,
},
Vorhesage B/.style={
B/.try,
correct color=Klasse B,
incorrect color=Klasse A,
shift={(5,0)}
},
iteration 1/.style={
% Define the testproben (and vorhesagen) for iteration 1
A/.style={
testproben={1-4}, % testproben row 1, column 4
testproben={2-3}, testproben={2-5},
testproben *={3-1}, testproben={3-2},
},
B/.style={
testproben={1-2}, testproben={1-3},
testproben *={2-1},
testproben={3-4}
},
},
iteration 2/.style={
A/.style={
testproben={1-1}, testproben={1-4},testproben={1-5},
testproben={2-2},
testproben={3-5}
},
B/.style={
testproben={1-2}, testproben={2-1},
testproben={3-1}, testproben={3-3}
}
},
iteration 3/.style={
A/.style={
testproben={1-5}, testproben={1-4},
testproben={2-2}, testproben={2-2},
testproben *={3-1}
},
B/.style={
testproben={1-2},
testproben={2-1},
testproben={3-3}, testproben={3-4}
},
}
}
\begin{document}
\begin{tikzpicture}[x=0.75cm, y=0.75cm, >=stealth]
\foreach \itr in {1,2,3}{
% Install the A and B styles for this iteration.
% The A and B styles define the testproben for Klasse A
% and Kasse B.
\tikzset{iteration \itr/.try}
\foreach \g in {1,2,3}{
\ifcase\g
\or
% Draw the probes
\foreach \K/\I/\J in {A/3/5, B/3/4}{%
% Install the Daten \K style.
% For Daten Klasse A this sets the probe color to blue
% For Daten Klasse B this sets the probe color to red
% and shifts everything along.
% In both cases the relevant style (A or B) is `executed'
% defining which probes are testproben.
\tikzset{Daten \K/.try}
\foreach \i in {1, ..., \I}{%
\foreach \j in {1, ..., \J}{%
\node (probe \itr-\K-\i-\j) at (\j, -\itr*3.5-\i)
[probe=\i-\j] {};
}
}
% Define a node that fits around all the nodes for this
% particular Daten Klasse.
\node [tight fit,fit=(probe \itr-\K-1-1)
(probe \itr-\K-\I-\J)]
(iteration \itr\space daten \K){};
}
\or
% Now draw the Surrogats (Surrogaten?)
\foreach \I in {1,2,3}{
\tikzset{shift=(probe \itr-B-1-4.east)}
\node (surrogat \itr-\I) at (1.125,1-\I) [surrogat] {};
\draw [ultra thick, ->]
(surrogat \itr-\I.west) ++(-0.625,0) -- ++(0.5,0);
\draw [ultra thick, ->]
(surrogat \itr-\I.east) ++(0.125,0) -- ++(0.5,0);
}
\or
% Finally the Forcasts
%
% Shift things along a but from the surrogats.
\tikzset{shift={(surrogat \itr-1)}, shift=(0:0.5)}
\foreach \K/\I/\J in {A/3/5, B/3/4}{
% This is the same as for the Daten Klasse,
% execept tis time the vorhesage proben are drawn.
\tikzset{Vorhesage \K/.try}
\foreach \i in {1, ..., \I}{
\foreach \j in {1, ..., \J}{
\node (vorhesage \itr-\K-\i-\j) at (\j, -\i+1)
[vorhesage=\i-\j] {\vmark};
}
},
% Draw a node around each set of vorhesage nodes.
\node [tight fit,
fit=(vorhesage \itr-\K-1-1) (vorhesage \itr-\K-\I-\J)]
(iteration \itr\space vorhesage \K){};
}
\fi%
}
}
% Now add the labels and delimiters.
\foreach \itr in {1,2,3}{
\node [tight fit, fit={(iteration \itr\space daten A)}, left
delimiter=\{, label={[xshift=-0.5cm]left:\itr.
Iteration}] {};
}
\foreach \K in {A, B}{
\node [tight fit, fit={(iteration 1 daten \K)}, above
delimiter=\{,label={[yshift=0.5cm]90:Daten Klassen \K}] {};
\node [tight fit, fit={(iteration 1 vorhesage \K)}, above
delimiter=\{,label={[yshift=0.5cm, align=center]90:{Vorhesage
\\Proben \K}}] {};
}
\node [fill=testproben, rounded corners=1ex, below=0.25cm, anchor=north west]
(testprobe)
at (probe 3-A-3-1.south east){Testprobe};
\draw [very thick, ->, rounded corners=1ex]
(testprobe.west) -| (probe 3-A-3-1.south);
\node [below=0.25cm, anchor=north west]
(trainingsprobe)
at (probe 3-A-3-4.south east){Trainingsprobe};
\draw [very thick, ->, rounded corners=1ex]
(trainingsprobe.west) -| (probe 3-A-3-4.south);
\node [below=1cm, anchor=north east]
(surrogatsmodelle)
at (surrogat 3-3.south west){$i=3\times k=3$ Surrogatsmodelle};
\draw [very thick, ->, rounded corners=1ex]
(surrogatsmodelle.east) -| (surrogat 3-3.south);
\node [below=0.5cm, align=left, anchor=north west] (eingeordnet)
at (vorhesage 3-A-3-1.south east){Testprobe aus Klasse \textcolor{Klasse
A}{A} wird \\als Klasse \textcolor{Klasse B}{B} eingeordnet};
\draw [very thick, ->, rounded corners=1ex]
(eingeordnet.west) -| (vorhesage 3-A-3-1.south);
\end{tikzpicture}
\end{document}
Update:
This new solution is a bit longer, but overcomes all three difficulties I list for the previous solution (below). In particular, this is a vector graphic.
Since you expressed an interest in imitating a 3D helix with hidden lines, I also produced an example of that (in grayscale vector graphics with no shading):
To compile either of these, 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);
}
}
triple[] derivative(surface s, pair pt) {
patchWithCoords thepatch = patchWithCoords(s, pt.x, pt.y);
return new triple[] {thepatch.partialu(), thepatch.partialv()};
}
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;
triple camera;
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); }
triple[] derivative(real u, real v) { return derivative(s, (u/sumax, v/svmax)); }
triple[] derivative(pair uv) { return derivative(uv.x, uv.y); }
pen color(real u, real v, material m, light light) {
return color(normal=normal(u,v), m=m, light=light);
}
pen color(pair uv, material m, light light) {
return this.color(uv.x, uv.y, m, light);
}
pair project(triple pt) { return project(pt, theProjection); }
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);
camera=theProjection.camera;
if(theProjection.infinity) {
triple m=min(s);
triple M=max(s);
camera = theProjection.target
+ camerafactor*(abs(M-m)+abs(m-theProjection.target))*unit(theProjection.vector());
}
}
int numSheetsHiding(pair parampt) {
return numSheetsHiding(s, scale(sumax,svmax)*parampt);
}
int numSheetsHiding(real u, real v) {
return numSheetsHiding((u,v));
}
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;
}
path3 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);
}
return onSurface(parampath);
}
}
SmoothSurface operator *(transform3 t, SmoothSurface s) {
return SmoothSurface(t*s.s);
}
To get the first image (with the two circles), in the same directory, run the following *.asy code:
settings.outformat="pdf";
import surfacepaths;
unitsize(1.5cm);
triple eye = 4*(0,1,3.5);
currentprojection=perspective(eye, up=Y);
surface torus = surface(O, shift(2X)*path3(scale(0.4)*unitcircle), axis=Y);
SmoothSurface Torus = SmoothSurface(torus);
Torus.drawSilhouette();
real diff = .07;
real midpoint = .75;
path circle1 = project(Torus.drawSurfacePath((midpoint-diff, 0) -- (midpoint-diff, 1)), ninterpolate=1);
path circle2 = project(Torus.drawSurfacePath((midpoint+diff,0) -- (midpoint+diff,1)),ninterpolate=1);
drawLayeredPaths(); // Draw the paths (with hidden path removal) that were computed in the previous code block.
real circle1mintime = mintimes(circle1)[1]; // the time at which circle1 reaches its minimum vertical extent
pair p1 = point(circle1, circle1mintime);
label("$\mathcal C$", position=p1, align=SW);
real circle2mintime = mintimes(circle2)[1];
pair p2 = point(circle2, circle2mintime);
label("$\mathcal C'$", position=p2, align=SE);
diff += .01;
path3 arc = Torus.onSurface((midpoint-diff,.75) -- (midpoint+diff,.75));
draw(shift(0,-1)*project(arc), arrow=ArcArrow());
To get the torus wrapped in a helix, run the following Asymptote code:
settings.outformat="pdf";
import surfacepaths;
size(400,0);
currentprojection=perspective(camera=(0,4,14), up=Y);
//function to return a line, but split into n parts (for better approximation when the line is transformed to lie on the surface)
path splitline(pair a, pair b, int n) {
pair f(real t) { return (1-t)*a + t*b; }
return graph(f, 0, 1, n=n);
}
surface torus = surface(O, Circle(c=2X,r=0.4,normal=Z,n=32), axis=Y, n=32);
/* Let Asymptote know (in case it did not already) that the u and v
* coordinates of this surface are both cyclic.
*/
torus.ucyclic(true);
torus.vcyclic(true);
SmoothSurface Torus = SmoothSurface(torus);
Torus.drawSilhouette(includePathsBehind=true);
Torus.drawSurfacePath(splitline((0,0), (1,20), n=100), p=gray);
drawLayeredPaths();
Old (rasterized-only) solution:
Here's an Asymptote solution that sort of works.
Note that as currently formulated, it has the following difficulties:
- The torus must be opaque.
- Anything that should be partially obscured by the torus has to be given in rasterized output (although I've got a scaling factor included to give high resolution). The rest of the image (i.e., the labels and the arrow) is vector output.
- It only works with an orthographic projection.
Anyway, here's the code:
import graph3;
import contour;
// A bunch of auxiliary functions for drawing silhouettes.
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) {
real toreturn(real u, real v) {
return dot(s.normal(u, v), eyedir);
}
return toreturn;
}
guide[] normalpathuv(surface s, triple eyedir) {
return contour(normalDot(s, eyedir), uvmin(s), uvmax(s), new real[] {0})[0];
}
path3 onSurface(surface s, path p) {
triple f(real t) {
pair point = point(p,t);
return s.point(point.x, point.y);
}
if (cyclic(p)) {
guide3 toreturn = f(0);
for (int i = 1; i < size(p); ++i)
toreturn = toreturn -- f(i);
toreturn = toreturn -- cycle;
return toreturn;
}
return graph(f, 0, length(p));
}
/*
* This method returns an array of paths that trace out all the
* points on s at which s is normal to eyedir.
*/
path3[] silhouetteNormal(surface s, triple eyedir) {
guide[] uvpaths = normalpathuv(s, eyedir);
path3[] toreturn = new path3[uvpaths.length];
for (int i = 0; i < uvpaths.length; ++i) {
toreturn[i] = onSurface(s, uvpaths[i]);
}
return toreturn;
}
/*
* Now, let's actually draw the picture.
*/
settings.outformat="pdf";
int resolutionfactor = 4;
settings.render=2*resolutionfactor;
settings.prc=false;
unitsize(1.5cm);
triple eye = (0,1,3);
currentprojection=orthographic(eye, up=Y);
surface torus = surface(O, shift(2X)*path3(scale(0.5)*unitcircle), axis=Y);
draw(silhouetteNormal(torus, eye));
draw(torus, surfacepen=emissive(white));
real umin = umin(torus);
real umax = umax(torus);
real diff = 0.07;
path3 circle1 = torus.uequals((.75-diff)*umax);
draw(circle1);
pair p1 = project(point(circle1, 3));
label("$\mathcal C$", position=p1, align=2SW);
path3 circle2 = torus.uequals((.75+diff)*umax);
draw(circle2);
pair p2 = project(point(circle2,3));
label("$\mathcal C'$", position=p2, align=2SE);
pair midpoint = (p1 + p2)/2 + (0,-.1);
path arc = p1 .. midpoint .. p2;
draw(shift(0,-1)*arc, arrow=ArcArrow());
shipout(scale(resolutionfactor)*currentpicture.fit());
Best Answer
The quickest solution in this case is to do a reflection using
xscale=-1in the answer to the question linked:If you don't want to use a reflection, simply redraw the path using the appropriate points for the arcs and the straight line segments: