algorithm for parametric surfaces design in 3d.

[tendaishava]

i am looking for information source on an algorithm for parametric surfaces design in 3d. i just need advice on how to go about it. the language used for the algorithm is not a matter but rather the idea on how the algorithm is to be is of paramount importance. below i have shown what i want to achieve.

[mike_2000_17]

First of all, the field in question is computational geometry.

Then, within that field there are volumetric representations and boundary representations (or B-Rep). Most B-Reps are parametric.

There are a number of fundamental representations used for curves and surfaces (and higher order geometries). Most are based on the construction of some mathematical formula (a high-order polynomial or some piece-wise continuous patches of lower-order polynomials (splines), or some other more isoteric representations) based on a set of control-points (or knots) which are either a part of the curve/surface or just points that sort-of pulls the curve/surface in different directions but do not lie on the curve/surface. Different representations are used in different contexts because they possess different qualities (smoothness, efficiency, uniform parametrization, meaningful parametrization (e.g. cord-length parametrization), etc.).

Here are a few methods of paramount importance (you need to understand them to go any further). Most method work for curves and can be extended to surfaces, but some are specialized for surfaces.

• Splines: This is a piece-wise interpolation between two control-points (and higher-order information like tangent vectors and normal vectors at the control points). This method is basically just a matter of solving for a polynomial of sufficient degree to ensure that the end-points match the control-points (and their higher-order vectors). For example, in first-order, you would solve for a straight-line (or plane) between two points (or three surface points), but normally you go with a higher-order interpolation (cubic or quintic). The nice thing with splines is that it is simple and reasonably cheap, and you can use any parameter you want (uniform, or approximately at cord-length, or something else). The problem is that the when the end-points are too difficult to interpolate, it will generate a pretty wild curve or surface. So this is not used as much in computer graphics or geometry, but very important in motion-planning and other applications that require smooth interpolations. For surfaces, you use a bicubic interpolation.
• B-Splines: This is similar to a spline except that instead of having two end-points with their associated higher-order vectors (tangent, normal, binormal, etc.), it uses intermediate control-points (that don't fall on the curve/surface) that represent this slope and curvature information. The set of points is called the "support" of the B-spline. B-Splines are somewhat equivalent to splines in terms of characteristics, but the definition of the support is sometimes easier than with splines, so it lends itself a bit better to using it for geometric representations. Generating them is also efficient with deBoor's algorithm. Again, for surfaces, you do a kind of bicubic generalization of it, as in here.
• Bézier curves and surfaces (which can also be patched together in a piece-wise continuous fashion): This is a method that is similar in nature to the B-splines (in fact, B-splines are a generalization of Bézier curves), but somewhat simpler. This is definitely the first viable candidate to be seriously applied for representing geometries. In fact, most vector-graphics editors (like Adobe Illustrator, or MS Visio, or Inkscape) use Bézier splines to create those curved lines in the drawings. Similarly, Bézier surfaces are very widely used in 3D computer graphics for representing smooth surfaces. However, there are a few limits to what this method can generate, mostly, it cannot represent sharp edges or weirdly curved surfaces too well. Bézier curves are generated efficiently with deCasteljau's algorithm.
• NURBS (Non-Uniform Rational B-Splines): This technique is pretty much as general as it can be. The use of NURBS surfaces in computer graphics is unmatched, it dominates the scene completely when it comes to parametric surfaces (with the exception of Bézier patches that are used in some special circumstances). NURBS can represent both extremes: sharp edged surfaces and perfect analytical shapes (e.g. spheres, cylinders, etc.). In theory, you could use NURBS patches to represent everything. They can be complicated to understand (you should understand the above methods before digging into NURBS), but they are also widely supported from the software level even to the hardware level (graphics cards normally have hardware pipelines in place to render NURBS surfaces on the screen).

The above list is not exhaustive but it is pretty much the main methods to know for general purpose parametric surfaces or curves.

You should also check out some important libraries for computational geometry, like CGAL and OpenCascade (which is more for CAD, i.e., volumetric representations and mesh generation). And, if you need this for a computer game or something like that, then you should look into graphics engines or game engines which usually include a lot of this code for geometric representations.

These are just some suggestions, please tell more about what you specifically want to achieve, and I can give you further pointers.