section s of routines in slice3.i

Home Manual Packages Global Index Keywords Quick Reference | # functions in slice3.i - s
slice2 |
                 slice2, plane, nverts, xyzverts
              or slice2, plane, nverts, xyzverts, values

         Slice a polygon list, retaining only those polygons or
         parts of polygons on the positive side of PLANE, that is,
         the side where xyz(+)*PLANE(+:1:3)-PLANE(4) > 0.0.
         The NVERTS, XYZVERTS, and VALUES arrays serve as both
         input and output, and have the meanings of the return
         values from the slice3 function.  It is legal to omit the
         VALUES argument (e.g.- if there is no fcolor function).
         In order to plot two intersecting slices, one could
         slice (for example) the horizontal plane twice (slice2x) -
         first with the plane of the vertical slice, then with minus
         that same plane.  Then, plot first the back part of the
         slice, then the vertical slice, then the front part of the
         horizontal slice.  Of course, the vertical plane could
         be the one to be sliced, and "back" and "front" vary
         depending on the view point, but the general idea always
         works.

    interpreted function, defined at i/slice3.i   line 880
SEE ALSO: | slice3, plane3, slice2x, slice2_precision
slice2_precision |
                 slice2_precision= precision

         Controls how slice2 (or slice2x) handles points very close to
         the slicing plane.  PRECISION should be a positive number or zero.
         Zero PRECISION means to clip exactly to the plane, with points
         exactly on the plane acting as if they were slightly on the side
         the normal points toward.  Positive PRECISION means that edges
         are clipped to parallel planes a distance PRECISION on either
         side of the given plane.  (Polygons lying entirely between these
         planes are completely discarded.)
         Default value is 0.0.

    keyword,  defined at i/slice3.i   line 1017
SEE ALSO: | slice2, slice2x
slice2x |
                 slice2, plane, nverts, values, xyzverts

         Slice a polygon list, retaining only those polygons or
         parts of polygons on the positive side of PLANE, that is,
         the side where xyz(+)*PLANE(+:1:3)-PLANE(4) > 0.0.
         The NVERTS, VALUES, and XYZVERTS arrays serve as both
         input and output, and have the meanings of the return
         values from the slice3 function.

    interpreted function, defined at i/slice3.i   line 863
SEE ALSO: | slice2, slice2_precision
slice3 |
                 slice3, m3, fslice, nverts, xyzverts

              or color_values= slice3(m3, fslice, nverts, xyzverts, fcolor)

              or color_values= slice3(m3, fslice, nverts, xyzverts, fcolor, 1)

         slice the 3D mesh M3 using the slicing function FSLICE, returning
         the lists NVERTS and XYZVERTS.  NVERTS is the number of vertices
         in each polygon of the slice, and XYZVERTS is the 3-by-sum(NVERTS)
         list of polygon vertices.  If the FCOLOR argument is present, the
         values of that coloring function on the polygons are returned as
         the value of the slice3 function (numberof(color_values) ==
         numberof(NVERTS) == number of polygons).
         If the slice function FSLICE is a function, it should be of the
         form:
            func fslice(m3, chunk)
         returning a list of function values on the specified chunk of the
         mesh m3.  The format of chunk depends on the type of m3 mesh, so
         you should use only the other mesh functions xyz3 and getv3 which
         take m3 and chunk as arguments.  The return value of fslice should
         have the same dimensions as the return value of getv3; the return
         value of xyz3 has an additional first dimension of length 3.
         If FSLICE is a list of 4 numbers, it is taken as a slicing plane
         with the equation FSLICE(+:1:3)*xyz(+)-FSLICE(4), as returned by
         plane3.
         If FSLICE is a single integer, the slice will be an isosurface for
         the FSLICEth variable associated with the mesh M3.  In this case,
         the keyword value= must also be present, representing the value
         of that variable on the isosurface.
         If FCOLOR is nil, slice3 returns nil.  If you want to color the
         polygons in a manner that depends only on their vertex coordinates
         (e.g.- by a 3D shading calculation), use this mode.
         If FCOLOR is a function, it should be of the form:
            func fcolor(m3, cells, l, u, fsl, fsu, ihist)
         returning a list of function values on the specified cells of the
         mesh m3.  The cells argument will be the list of cell indices in
         m3 at which values are to be returned.  l, u, fsl, fsu, and ihist
         are interpolation coefficients which can be used to interpolate
         from vertex centered values to the required cell centered values,
         ignoring the cells argument.  See getc3 source code.
         The return values should always have dimsof(cells).
         If FCOLOR is a single integer, the slice will be an isosurface for
         the FCOLORth variable associated with the mesh M3.
         If the optional argument after FCOLOR is non-nil and non-zero,
         then the FCOLOR function is called with only two arguments:
            func fcolor(m3, cells)

    interpreted function, defined at i/slice3.i   line 203
SEE ALSO: | mesh3, plane3, xyz3, getv3, getc3, slice2, plfp
split_bytscl |
                 split_bytscl(x, 0)
              or split_bytscl(x, 1)

         as bytscl function, but scale to the lower half of a split
         palette (0-99, normally the color scale) if the second parameter
         is zero or nil, or the upper half (100-199, normally the gray
         scale) if the second parameter is non-zero.

    interpreted function, defined at i/slice3.i   line 1253
SEE ALSO: | split_palette
split_palette |
                 split_palette
              or split_palette, "palette_name.gp"

         split the current palette or the specified palette into two
         parts; colors 0 to 99 will be a compressed version of the
         original, while colors 100 to 199 will be a gray scale.

    interpreted function, defined at i/slice3.i   line 1226
SEE ALSO: | pl3tree, split_bytscl