## visad
Class DelaunayCustom

    java.lang.Object
      visad.Delaunay
          visad.DelaunayCustom

All Implemented Interfaces:
  Serializable

public class DelaunayCustom
extends Delaunay

DelaunayCustom is a set of constructors to create an instance of Delaunay by passing in a pre-computed triangulation. DelaunayCustom is useful for creating instances of Delaunay that can be passed into IrregularSet. If you want to perform consistency checks on your triangulation, call Delaunay.test() on your DelaunayCustom object after it is constructed.

See Also:
  Serialized Form

Field Summary

Fields inherited from class visad.Delaunay
`Edges, NumEdges, Tri, Vertices, Walk`

Constructor Summary
`DelaunayCustom(float[][] samples, int[][] tri)` construct a Delaunay from point locations and a list of triangles; call finish_triang() to fill in helper arrays (vertices, walk and edges); copy arguments
`DelaunayCustom(float[][] samples, int[][] tri, int[][] vertices, int[][] walk, int[][] edges, int num_edges)` construct a Delaunay from point locations, a list of triangles, and helper arrays (vertices, walk and edges); copy arguments
`DelaunayCustom(float[][] samples, int[][] tri, int[][] vertices, int[][] walk, int[][] edges, int num_edges, boolean copy)` construct a Delaunay from point locations, a list of triangles, and helper arrays (vertices, walk and edges); copy arguments

Method Summary
`static boolean` `checkAndFixSelfIntersection(float[][] samples)` determine if a closed path self-intersects, and remove consecutive identical points
`static boolean` `checkSelfIntersection(float[][] samples)` determine if a closed path self-intersects
`static boolean` `checkSelfIntersection(Gridded2DSet set)` determine if a closed path self-intersects
`static void` `clip(float[][] samples, int[][] tris, float xc, float yc, float v, float[][][] outs, int[][][] outt)` clip the topology (samples, tris) against the half-plane xc * x + yc * y <= v and return the clipped topology
`static float` `computeArea(float[][] samples)` compute the area inside a set of closed paths
`static float` `computeArea(Gridded2DSet set)` compute the area inside a set of closed paths
`static float` `computeArea(UnionSet set)` compute the area inside a set of closed paths
`static int[][]` `fill(float[][] samples)` check that samples describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples; the trick is that the region may not be convex, but the triangles must all lie inside the region
`static Irregular2DSet` `fill(Gridded2DSet set)` check that set describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples, as an Irregular2DSet
`static Irregular2DSet` `fill(UnionSet set)` check that set describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples, as an Irregular2DSet
`static int[][]` `fillCheck(float[][] samples, boolean check)` check that samples describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples; the trick is that the region may not be convex, but the triangles must all lie inside the region
`static Irregular2DSet` `fillCheck(Gridded2DSet set, boolean check)` check that set describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples, as an Irregular2DSet
`static Irregular2DSet` `fillCheck(UnionSet set, boolean check)` check that set describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples, as an Irregular2DSet
`static boolean` `inside(float[][] s, float x, float y)` determine if a point is inside a closed path
`static float[][]` `link(float[][][] ss)` link multiple paths into a single path; this assumes that the paths in ss don't intersect each other but does test for self-intersection by each path

Methods inherited from class visad.Delaunay
`clone, factory, finish_triang, getNonConvex, improve, perturb, sampleString, scale, setNonConvex, test, test, toString`

Methods inherited from class java.lang.Object
`equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### DelaunayCustom

    public DelaunayCustom(float[][] samples,
                          int[][] tri)
                   throws VisADException

  construct a Delaunay from point locations and a list of triangles; call finish_triang() to fill in helper arrays (vertices, walk and edges); copy arguments

Parameters:
  `samples` - locations of points for topology - dimensioned float[dimension][number_of_points]
  `tri` - list of triangles - dimensioned int[ntris][dim + 1] tris values are indices into second index of samples
Throws:
  `VisADException` - a VisAD error occurred

### DelaunayCustom

    public DelaunayCustom(float[][] samples,
                          int[][] tri,
                          int[][] vertices,
                          int[][] walk,
                          int[][] edges,
                          int num_edges)
                   throws VisADException

  construct a Delaunay from point locations, a list of triangles, and helper arrays (vertices, walk and edges); copy arguments

Parameters:
  `samples` - locations of points for topology - dimensioned float[dimension][number_of_points]
  `tri` - list of triangles - dimensioned int[ntris][dim + 1] tris values are indices into second index of samples
  `vertices` - links from vertices to triangles/tetrahedra - dimensioned int[number_of_points][nverts[i]]
  `walk` - links from triangles/tetrahedra to neighboring triangles/tetrahedra - dimensioned int[ntris][dim + 1]
  `edges` - links from tri/tetra edges to global edge numbers - dimensioned int[ntris][3 * (dim - 1)]
  `num_edges` - number of global edges
Throws:
  `VisADException` - a VisAD error occurred

### DelaunayCustom

    public DelaunayCustom(float[][] samples,
                          int[][] tri,
                          int[][] vertices,
                          int[][] walk,
                          int[][] edges,
                          int num_edges,
                          boolean copy)
                   throws VisADException

  construct a Delaunay from point locations, a list of triangles, and helper arrays (vertices, walk and edges); copy arguments

Parameters:
  `samples` - locations of points for topology - dimensioned float[dimension][number_of_points]
  `tri` - list of triangles - dimensioned int[ntris][dim + 1] tris values are indices into second index of samples
  `vertices` - links from vertices to triangles/tetrahedra - dimensioned int[number_of_points][nverts[i]]
  `walk` - links from triangles/tetrahedra to neighboring triangles/tetrahedra - dimensioned int[ntris][dim + 1]
  `edges` - links from tri/tetra edges to global edge numbers - dimensioned int[ntris][3 * (dim - 1)]
  `num_edges` - number of global edges
  `copy` - flag indicating whether to copy arrays
Throws:
  `VisADException` - a VisAD error occurred

Method Detail

### checkSelfIntersection

    public static boolean checkSelfIntersection(Gridded2DSet set)
                                         throws VisADException

  determine if a closed path self-intersects

  Parameters:
    `set` - Gridded2DSet with manifold dimension = 1
  Returns:
    true if closed path in set self-intersects
  Throws:
    `VisADException` - a VisAD error occurred

### checkSelfIntersection

    public static boolean checkSelfIntersection(float[][] samples)
                                         throws VisADException

  determine if a closed path self-intersects

  Parameters:
    `samples` - locations of points on closed path - dimensioned float[2][number_of_points]
  Returns:
    true if closed path in samples self-intersects
  Throws:
    `VisADException` - a VisAD error occurred

### checkAndFixSelfIntersection

    public static boolean checkAndFixSelfIntersection(float[][] samples)
                                               throws VisADException

  determine if a closed path self-intersects, and remove consecutive identical points

  Parameters:
    `samples` - locations of points on closed path - dimensioned float[2][number_of_points] - may be modified on return
  Returns:
    true if closed path in samples self-intersects
  Throws:
    `VisADException` - a VisAD error occurred

### computeArea

    public static float computeArea(UnionSet set)
                             throws VisADException

  compute the area inside a set of closed paths

  Parameters:
    `set` - UnionSet of Gridded2DSets with manifold dimension = 1, interpreted as a set of closed paths
  Returns:
    sum of areas inside closed paths
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### computeArea

    public static float computeArea(Gridded2DSet set)
                             throws VisADException

  compute the area inside a set of closed paths

  Parameters:
    `set` - Gridded2DSet with manifold dimension = 1, interpreted as a closed path
  Returns:
    area inside closed path
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### computeArea

    public static float computeArea(float[][] samples)
                             throws VisADException

  compute the area inside a set of closed paths

  Parameters:
    `samples` - locations of points on closed path - dimensioned float[2][number_of_points]
  Returns:
    area inside closed path
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### fill

    public static Irregular2DSet fill(Gridded2DSet set)
                               throws VisADException

  check that set describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples, as an Irregular2DSet

  Parameters:
    `set` - Gridded2DSet with manifold dimension = 1, interpreted as a closed path boundary
  Returns:
    Irregular2DSet whose triangles form the interior of the region enclosed by set
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### fillCheck

    public static Irregular2DSet fillCheck(Gridded2DSet set,
                                           boolean check)
                                    throws VisADException

  check that set describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples, as an Irregular2DSet

  Parameters:
    `set` - Gridded2DSet with manifold dimension = 1, interpreted as a closed path boundary
    `check` - if true then throw a VisADException if path self- intersects, else just return null
  Returns:
    Irregular2DSet whose triangles form the interior of the region enclosed by set
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### fill

    public static int[][] fill(float[][] samples)
                        throws VisADException

  check that samples describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples; the trick is that the region may not be convex, but the triangles must all lie inside the region

  Parameters:
    `samples` - locations of points on closed path - dimensioned float[2][number_of_points]
  Returns:
    triangles that form the interior of the region enclosed by samples - dimensioned int[ntris][dim + 1]
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### fillCheck

    public static int[][] fillCheck(float[][] samples,
                                    boolean check)
                             throws VisADException

  check that samples describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples; the trick is that the region may not be convex, but the triangles must all lie inside the region

  Parameters:
    `samples` - locations of points on closed path - dimensioned float[2][number_of_points]
    `check` - if true then throw a VisADException if path self- intersects, else just return null
  Returns:
    triangles that form the interior of the region enclosed by samples - dimensioned int[ntris][dim + 1]
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### fill

    public static Irregular2DSet fill(UnionSet set)
                               throws VisADException

  check that set describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples, as an Irregular2DSet

  Parameters:
    `set` - UnionSet of Gridded2DSets with manifold dimension = 1, interpreted as a set of closed paths
  Returns:
    Irregular2DSet whose triangles form the interior of the region enclosed by set
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### fillCheck

    public static Irregular2DSet fillCheck(UnionSet set,
                                           boolean check)
                                    throws VisADException

  check that set describes the boundary of a simply connected plane region; return a decomposition of that region into triangles whose vertices are all boundary points from samples, as an Irregular2DSet

  Parameters:
    `set` - UnionSet of Gridded2DSets with manifold dimension = 1, interpreted as a set of closed paths
    `check` - if true then throw a VisADException if path self- intersects, else just return null
  Returns:
    Irregular2DSet whose triangles form the interior of the region enclosed by set
  Throws:
    `VisADException` - path self intersects or a VisAD error occurred

### link

    public static float[][] link(float[][][] ss)
                          throws VisADException

  link multiple paths into a single path; this assumes that the paths in ss don't intersect each other but does test for self-intersection by each path

  Parameters:
    `ss` - a set of paths - dimensioned float[number_of_paths][2][number_of_points_for_path]
  Returns:
    a path dimensioned float [2][number_of_points]
  Throws:
    `VisADException` - a path self intersects or a VisAD error occurred

### inside

    public static boolean inside(float[][] s,
                                 float x,
                                 float y)
                          throws VisADException

  determine if a point is inside a closed path

  Parameters:
    `s` - locations of points on closed path - dimensioned float[2][number_of_points]
    `x` - first coordinate of point
    `y` - second coordinate of point
  Returns:
    true if point (x, y) is inside the path s
  Throws:
    `VisADException` - a VisAD error occurred

### clip

    public static void clip(float[][] samples,
                            int[][] tris,
                            float xc,
                            float yc,
                            float v,
                            float[][][] outs,
                            int[][][] outt)
                     throws VisADException

  clip the topology (samples, tris) against the half-plane xc * x + yc * y <= v and return the clipped topology

  Parameters:
    `samples` - locations of points for topology - dimensioned float[dimension][number_of_points]
    `tris` - list of triangles - dimensioned int[ntris][dim + 1] tris values are indices into second index of samples
    `xc` - x coefficient in half-plane inequality
    `yc` - y coefficient in half-plane inequality
    `v` - constant in half-plane inequality
    `outs` - array dimensioned float[1][][] to take samples of clipped topology - on output dimensioned float[1][2][number_of_output_samples]
    `outt` - array dimensioned int[1][][] to take tris of clipped topology - on output dimensioned int[1][number_of_output_triangles][3]
  Throws:
    `VisADException` - a VisAD error occurred