If both surfaces are implicit, then intersectplot divides the three dimensional region into rectangular cells at the initial resolution, then computes the values of the two implicit functions at all corners of the cells.

Each cell is divided into 4 tetrahedra, and any of the tetrahedra where both of the implicit surfaces intersect are stored for further processing.

The algorithm then iterates a number of times, splitting each stored tetrahedra into 4 tetrahedra, retaining only those that both surfaces intersect. This continues for either three passes or until the total number of tetrahedra exceeds 50000.

Finally, the intersections are interpolated by a line segment inside each tetrahedra, which produces the final plot.

The available options are:

grid - positive integer, or list of 3 positive integers (default 10). This specifies the number of cells to divide the three dimensional region into along each dimension. Specification of 100, for example, would require 100x100x100 or one million cells, so best to be a bit conservative, and use maxlev below to increase refinement.

maxlev - nonnegative integer (default 3). This specifies the number of subdivision iterations to perform on the tetrahedra from the initial grid. Note that each subdivision is equivalent to a doubling of the number of cells initially used, so by default, the output detail level is equivalent to a 2^3*10=80 cubed grid. Setting maxlev to 4 would give a 2^4*10=160 cubed grid.

maxtet - positive integer (default 50000). This specifies a bound on the number of tetrahedra to halt the subdivision process. This does not actually bound the number of tetrahedra that are examined for line segments. For example, if we have 49999 tetrahedra, and another subdivision iteration is performed, we may end up with as many as 4*49999=199996 tetrahedra, and as many line segments.

If one surface is either parametric or explicit while the other is either implicit or explicit, then one surface is treated as parametric, and the other is treated as implicit.

The intersection is computed as the zeros of the implicit function with the independent variables replaced by the parametric surface description. i.e. The intersection of F(x,y,z)=0 and [X(s,t),Y(s,t),Z(s,t)] is computed as the zeros of G(s,t)=F(X(s,t),Y(s,t),Z(s,t)) varying s and t.

The values of G(s,t) are computed on a rectangular mesh in s and t, each rectangle is divided into two triangles, and and triangles containing G(s,t)=0 are retained for further computation.

The retained triangles are then iteratively subdivided. At each step, a single triangle is divided into 4 triangles.

Finally, for each triangle containing a zero of G(s,t), a line segment is computed and placed in the output plot.

The available options are:

grid - positive integer, or list of 2 positive integers (default 25). This specifies the number of rectangles to divide the two dimensional parametric region into along each dimension. Specification of 100, for example, would require 100x100 or 10000 cells.

maxlev - nonnegative integer (default 5). This specifies the number of subdivision iterations to perform on the triangles from the initial grid. Note that each subdivision is equivalent to a doubling of the number of cells initially used, so by default, the output detail level is equivalent to a 2^5*25=800 squared grid. Setting maxlev to 4 would give a 2^4*25=400 squared grid.

maxtri - positive integer (default 50000). This specifies a bound on the number of triangles to halt the subdivision process. This does not actually bound the number of triangles that are examined for line segments. For example, if we have 49999 triangles, and another subdivision iteration is performed, we may end up with as many as 4*49999=199996 triangles, and as many line segments.

If both surfaces are parametric, then surfaceplot proceeds by forming the triangles describing each surface independently (2-d process), placing them into a 3-d array of bins that cover the 3-d area spanned by the surface intersection area.

Any bins that contain triangles from both surfaces are marked for further examination.

Each triangle in the marked bins is then subdivided into a specified number of subtriangles along each dimension, and these triangles are placed into a second set of finer bins.

Finally, for any of the finer bins that are common to both surfaces, the triangles from both surfaces are examined to detect intersections (line segments).

The available options are:

grid1 - positive integer, or list of 2 positive integers (default 10). This specifies the number of rectangles to divide the two dimensional parametric region into along each dimension for the first parametric surface. Specification of 20, for example, would require 20x20 or 400 cells.

grid2 - positive integer, or list of 2 positive integers (default 10). This is identical to grid1, except this applies to the second surface.

bins - positive integer (default 10). This specifies the number of bins to use, along each dimension when placing the triangles to assess whether they need further examination. Note that choosing too small a bit size will cause too many triangles to be included in each bin, while choosing too large a bin size will require significant memory be used for the bin array, and may require that too many bins require further examination. The optimal value is a balance to keep both the number of bins, and the number of triangles in each bin as small as possible.

subdivisions - nonnegative integer (default 5). This specifies the number of divisions to perform on the triangles for any that are in bins common to both curves. So specification of 5 will cause five additional values to be added along each axis, and as a result will break down each triangle into $(5+1)^2=36$ triangles. This allows for a refinement of the final plot. Note that the number of finer bins used in the second stage of the algorithm is given by bins*(subdivisions+1). At the default setting, the number of finer bins used is $10(5+1)=60$ along each axis.