Return to README.3d CVS log

Up to [local] / OpenXM_contrib / gnuplot / docs / old

Annotation of OpenXM_contrib/gnuplot/docs/old/README.3d, Revision 1.1

1.1     ! maekawa     1:
        !             2:                    A tutorial on explicit/parametric
        !             3:                                    and
        !             4:                     everything you did not dare to ask
        !             5:                                   about
        !             6:                            curves and surfaces
        !             7:                                     in
        !             8:                                   gnuplot
        !             9:
        !            10: Several types of curves and surface are supported in gnuplot. Of those
        !            11: not every operation is supported for every curve or surface type and it
        !            12: can be therefore useful to understand the different types, their advantages
        !            13: and limitations.
        !            14:
        !            15: Curves in gnuplot are almost always planar (with one exception which we
        !            16: will deal with in the end) and are assumed to be in the XY plane.
        !            17: Therefore only X and Y coordinates are needed for plotting curves.
        !            18: The simplest curve is the `explicit function`. This curve is in fact a
        !            19: function and for each given x, there is one and only one y value associated
        !            20: with it. A gnuplot example for such type is `plot sin(x)` or
        !            21: `plot "datafile" using 1". Note the later is using only a single column from
        !            22: the data file which is assumed to be the y values.
        !            23:
        !            24: Alternatively one can define a `parametric curve` form. In this case
        !            25: x and y are both functions of a third free parameter t, while independent
        !            26: of each other. A circle can be expressed parametrically as x = cos(t),
        !            27: y = sin(t) and be plotted using gnuplot as
        !            28: 'set parametric; plot cos(t),sin(t)'.
        !            29: This form is not a function since there can be unlimited number of y values
        !            30: associated with same x. Furthermore the explicit form is a special case of
        !            31: the parametric representation by letting x equal to t. The curve y = sin(x)
        !            32: can be written in parametric form as y = sin(t), x = t.
        !            33:
        !            34: We are used to think of the plane in cartesian coordinate system.
        !            35: In practice, some coordinate systems may be easier to use then others
        !            36: under some circumstances. The polar form uses a different basis
        !            37: to span the XY plane. In this representation the cartesian x coordinate
        !            38: is equal to r cos(t) and the cartesian y coordinate is equal to r sin(t).
        !            39: To draw a unit circle using the polar coordinate system in gnuplot use the
        !            40: following simple command: 'set polar; plot 1'. To better understand this
        !            41: explicit form lets backup a little.
        !            42: When we plot a regular explicit function like `y = sin(x)` we march in equal
        !            43: steps in x, evaluate the provided function and plot a piecewise linear curve
        !            44: between the sampled points approximating the real function. In the polar
        !            45: explicit form we do exactly the same thing, but we march along the angular
        !            46: direction - we turn around the origin, computing the length of the radius
        !            47: at that angle. Since for the unit circle, this radius is a constant 1,
        !            48: `plot 1` in polar form plots a circle (if t domain is from 0 or 2Pi).
        !            49: Note the polar form is explicit in that for each angle there is only a
        !            50: single radius.
        !            51:
        !            52: Surprisingly (or maybe not so surprising) surfaces share the same
        !            53: representations. Since surfaces are two dimensional entities, they
        !            54: require two free parameters (like t for curves).
        !            55:
        !            56: A surface explicit function uses x and y as the free parameters. For
        !            57: each such pair it provides a single z value. An example for this form
        !            58: can be `splot sin(sqrt(x**2+y**2))/sqrt(x**2+y**2)` for a three dimensional
        !            59: sinc function or `splot 'datafile' using 1`. As for curves, the single column
        !            60: used from the data file defines the function value or z in this case.
        !            61: The order of the x and y function values is very strict in this form and
        !            62: simply defines a rectangular grid in the XY plane. Fortunately this
        !            63: strict form allows us to apply a very simplistic hidden line algorithm
        !            64: called "the floating horizon". This hidden line algorithm exploits the
        !            65: rectangular XY domain of the surface and therefore may be used for this
        !            66: type of surfaces only. Since in gnuplot this is the only form of hidden
        !            67: lines removing algorithm provided, only explicit surfaces may have their
        !            68: hidden lines removed.
        !            69:
        !            70: Parametric surfaces are the exact extension for explicit surfaces as in
        !            71: the curves case. the x, y, and z are defined in terms of two new free
        !            72: variables and are totally independent of each other as x(u, v), y(u, v),
        !            73: and z(u, v). Again the explicit surface is a special case of the parametric
        !            74: representation where x = u, and y = v. Examples for plotting parametric
        !            75: surfaces in gnuplot can be `splot cos(u)*cos(v),cos(u)*sin(v),sin(u)` which
        !            76: defines a sphere, or `splot "datafile" using 1:2:3`. Since these are
        !            77: parametric surfaces, gnuplot must be informed to handle them by issuing
        !            78: `set parametric`.
        !            79:
        !            80: The curve polar form takes the obvious extensions in the surface world.
        !            81: The first possible extension is spherical coordinate system, while the
        !            82: second is the cylindrical one. These modes currently work for data files
        !            83: only and both requires two parameters, theta and phi for mapping onto the
        !            84: unit sphere, and theta and z form mapping on a unit radius cylinder as follow:
        !            85:
        !            86:         Spherical coord.                        Cylin. coord.
        !            87:         ----------------                        -------------
        !            88:         x = cos( theta ) * cos( phi )           x = cos( theta )
        !            89:         y = sin( theta ) * cos( phi )           y = sin( theta )
        !            90:         z = sin( phi )                          z = z
        !            91:
        !            92: This subject brings us back to non planar curves. When surfaces are displayed
        !            93: under gnuplot, isocurves are actually getting plotted. An isocurve is a
        !            94: curve on the surface in which one of the two free parameters of the
        !            95: surface is fixed. For example the u isolines of a surface are drawn by
        !            96: setting u to be fixed and varying v along the entire v domain. The v isolines
        !            97: are similarly drawn by fixing v. When data files are specified they are
        !            98: classified internally into two types. A surface is tagged to have grid
        !            99: topology if all its specified isolines are of the same length. A data mesh
        !           100: of five isolines, seven points each is an example. In such a case the
        !           101: surface cross isolines are drawn as well. Seven isolines with five points
        !           102: each will be automatically created and drawn for grid type data. If
        !           103: however, isolines of different length are found in the data, it is
        !           104: tagged as nongrid surface and in fact is nothing more than a collection
        !           105: of three dimensional curves. Only the provided data is plotted in that
        !           106: case (see world.dem for such an example).