java.lang.Object
- gov.nih.mipav.model.structures.Voro.voronoicell_base

Direct Known Subclasses:

Voro.voronoicell, Voro.voronoicell_neighbor

Enclosing class:

Voro
```
class Voro.voronoicell_base
extends java.lang.Object
```
\brief A class representing a single Voronoi cell. This class represents a single Voronoi cell, as a collection of vertices that are connected by edges. The class contains routines for initializing the Voronoi cell to be simple shapes such as a box, tetrahedron, or octahedron. It the contains routines for recomputing the cell based on cutting it by a plane, which forms the key routine for the Voronoi cell computation. It contains numerous routine for computing statistics about the Voronoi cell, and it can output the cell in several formats. This class is not intended for direct use, but forms the base of the voronoicell and voronoicell_neighbor classes, which extend it based on whether neighboring particle ID information needs to be tracked.

Field Summary

Fields
Modifier and Type	Field	Description
`double`	`big_tol`
`int`	`current_delete_size`	This sets the size of the main delete stack.
`int`	`current_delete2_size`	This sets the size of the auxiliary delete stack.
`int`	`current_vertex_order`	This holds the current maximum allowed order of a vertex, which sets the size of the mem, mep, and mec arrays.
`int`	`current_vertices`	This holds the current size of the arrays ed and nu, which hold the vertex information.
`int`	`current_xsearch_size`	This sets the size of the extra search stack.
`private int[]`	`ds`	This is the delete stack, used to store the vertices which are going to be deleted during the plane cutting procedure.
`private int[]`	`ds2`	This is the auxiliary delete stack, which has size set by current_delete2_size.
`int[]`	`ed`	This is a two dimensional array that holds information about the edge connections of the vertices that make up the cell.
`protected int[]`	`edmep`
`int[]`	`mask`
`private int`	`maskc`
`protected int[]`	`mec`	This is a one dimensional array that holds the current number of vertices of order p that are stored in the mep[p] array.
`protected int[]`	`mem`	This a one dimensional array that holds the current sizes of the memory allocations for them mep array.
`protected int[][]`	`mep`	This is a two dimensional array for holding the information about the edges of the Voronoi cell. mep[p] is a one-dimensional array for holding the edge information about all vertices of order p, with each vertex holding 2*p+1 integers of information.
`int[][]`	`mne`	This two dimensional array holds the neighbor information associated with each vertex. mne[p] is a one dimensional array which holds all of the neighbor information for vertices of order p.
`int[]`	`ne`	This is a two dimensional array that holds the neighbor information associated with each vertex. ne[i] points to a one-dimensional array in mne[nu[i]]. ne[i][j] holds the neighbor information associated with the jth edge of vertex i.
`int[]`	`nemne`
`int[]`	`nu`	This array holds the order of the vertices in the Voronoi cell.
`int`	`p`	This sets the total number of vertices in the current cell.
`private double`	`prsq`	The magnitude of the normal vector to the test plane.
`double[]`	`pts`	This in an array with size 3*current_vertices for holding the positions of the vertices.
`private double`	`px`	The x coordinate of the normal vector to the test plane.
`private double`	`py`	The y coordinate of the normal vector to the test plane.
`private double`	`pz`	The z coordinate of the normal vector to the test plane.
`protected int[]`	`q`
`(package private) int`	`stacke_index`
`(package private) int`	`stacke2_index`
`(package private) int`	`stacke3_index`
`(package private) int`	`stackp_index`
`(package private) int`	`stackp2_index`
`(package private) int`	`stackp3_index`
`double`	`tol`
`double`	`tol_cu`
`int`	`up`	This is the index of particular point in the cell, which is used to start the tracing routines for plane intersection and cutting.
`private int[]`	`xse`	This is the extra search stack.

Constructor Summary

Constructors
Constructor Description

voronoicell_base(double max_len_sq)
Constructs a Voronoi cell and sets up the initial memory.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private void`	`add_memory(Voro.voronoicell_neighbor vc, int i)`
`private void`	`add_memory(Voro.voronoicell vc, int i)`	Increases the memory storage for a particular vertex order, by increasing the size of the of the corresponding mep array.
`private void`	`add_memory_ds()`	Doubles the size allocation of the main delete stack.
`private void`	`add_memory_ds2()`	Doubles the size allocation of the auxiliary delete stack.
`private void`	`add_memory_vertices(Voro.voronoicell vc)`	Doubles the maximum number of vertices allowed, by reallocating the ed, nu, and pts arrays.
`private void`	`add_memory_vertices(Voro.voronoicell_neighbor vc)`
`private void`	`add_memory_vorder(Voro.voronoicell vc)`	Doubles the maximum allowed vertex order, by reallocating mem, mep, and mec arrays.
`private void`	`add_memory_vorder(Voro.voronoicell_neighbor vc)`
`private void`	`add_memory_xse()`	Doubles the size allocation of the auxiliary delete stack.
`private void`	`add_to_stack(int sc2, int lp)`	Adds a point to the auxiliary delete stack if it is not already there.
`void`	`centroid(double[] cx, double[] cy, double[] cz)`	Calculates the centroid of the Voronoi cell, by decomposing the cell into tetrahedra extending outward from the zeroth vertex.
`void`	`check_duplicates()`	This routine checks for any two vertices that are connected by more than one edge.
`protected void`	`check_memory_for_copy(Voro.voronoicell_neighbor vc, Voro.voronoicell_base vb)`
`protected void`	`check_memory_for_copy(Voro.voronoicell vc, Voro.voronoicell_base vb)`
`void`	`check_relations()`	Checks that the relational table of the Voronoi cell is accurate, and prints out any errors.
`private boolean`	`collapse_order1(Voro.voronoicell vc)`	Order one vertices can potentially be created during the order two collapse routine.
`private boolean`	`collapse_order1(Voro.voronoicell_neighbor vc)`
`private boolean`	`collapse_order2(Voro.voronoicell vc)`	During the creation of a new facet in the plane routine, it is possible that some order two vertices may arise.
`private boolean`	`collapse_order2(Voro.voronoicell_neighbor vc)`
`void`	`construct_relations()`	Constructs the relational table if the edges have been specified.
`protected void`	`copy(Voro.voronoicell_base vb)`	Copies the vertex and edge information from another class.
`private boolean`	`create_facet(Voro.voronoicell_neighbor vc, int lp, int ls, double l, int us, double u, int p_id)`
`private boolean`	`create_facet(Voro.voronoicell vc, int lp, int ls, double l, int us, double u, int p_id)`	Creates a new facet.
`int`	`cycle_down(int a, int p)`	This is a simple inline function for picking out the index of the next edge clockwise from the current vertex.
`int`	`cycle_up(int a, int p)`	This is a simple inline function for picking out the index of the next edge counterclockwise at the current vertex.
`private boolean`	`definite_max(int[] lp, int[] ls, double[] l, double[] u, int[] uw)`	Checks whether a particular point lp is a definite maximum, searching through any possible minor non-convexities, for a better maximum.
`private boolean`	`definite_min(int[] lp, int[] us, double[] l, double[] u, int[] lw)`
`void`	`delete()`	The voronoicell destructor deallocates all the dynamic memory.
`private boolean`	`delete_connection(Voro.voronoicell_neighbor vc, int j, int k, boolean hand)`
`private boolean`	`delete_connection(Voro.voronoicell vc, int j, int k, boolean hand)`	This routine deletes the kth edge of vertex j and reorganizes the memory.
`void`	`draw_gnuplot(double x, double y, double z, java.io.RandomAccessFile raFile)`	Outputs the edges of the Voronoi cell in gnuplot format to an output stream.
`void`	`draw_gnuplot(double x, double y, double z, java.lang.String filename)`	Outputs the cell in Gnuplot format a given file.
`void`	`draw_pov(double x, double y, double z, java.io.RandomAccessFile raFile)`	Outputs the edges of the Voronoi cell in POV-Ray format to an open file stream, displacing the cell by given vector.
`void`	`draw_pov(double x, double y, double z, java.lang.String filename)`	Outputs the cell in POV-Ray format, using cylinders for edges and spheres for vertices, to a given file.
`void`	`draw_pov_mesh(double x, double y, double z, java.io.RandomAccessFile raFile)`	Outputs the Voronoi cell in the POV mesh2 format, described in section 1.3.2.2 of the POV-Ray documentation.
`void`	`draw_pov_mesh(double x, double y, double z, java.lang.String filename)`	Outputs the cell in POV-Ray format as a mesh2 object to a given file.
`int`	`edc(int i, int j)`
`void`	`face_areas(java.util.Vector<java.lang.Double> v)`	Calculates the areas of each face of the Voronoi cell and prints the results to an output stream.
`void`	`face_freq_table(java.util.Vector<java.lang.Integer> v)`	Computes the number of edges that each face has and outputs a frequency table of the results.
`void`	`face_orders(java.util.Vector<java.lang.Integer> v)`	Outputs a list of the number of edges in each face.
`void`	`face_perimeters(java.util.Vector<java.lang.Double> v)`	This routine returns the perimeters of each face.
`void`	`face_vertices(java.util.Vector<java.lang.Integer> v)`	For each face, this routine outputs a bracketed sequence of numbers containing a list of all the vertices that make up that face.
`private void`	`flip(int tp)`
`void`	`init_base(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)`	Initializes a Voronoi cell as a rectangular box with the given dimensions.
`void`	`init_octahedron_base(double l)`	Initializes a Voronoi cell as a regular octahedron.
`void`	`init_tetrahedron_base(double x0, double y0, double z0, double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`	Initializes a Voronoi cell as a tetrahedron.
`private int`	`m_calc(int n, double[] ans)`
`private int`	`m_test(int n, double[] ans)`	Checks to see if a given vertex is inside, outside or within the test plane.
`private int`	`m_testx(int n, double[] ans)`	Checks to see if a given vertex is inside, outside or within the test plane.
`double`	`max_radius_squared()`	Computes the maximum radius squared of a vertex from the center of the cell.
`void`	`minkowski(double r, double[] ar, double[] vo)`	Calculates the contributions to the Minkowski functionals for this Voronoi cell.
`private void`	`minkowski_contrib(int i, int k, int m, double r, double[] ar, double[] vo)`
`private void`	`minkowski_edge(double x0, double r1, double s1, double r2, double s2, double r, double[] ar, double[] vo)`
`private void`	`minkowski_formula(double x0, double y0, double z0, double r, double[] ar, double[] vo)`
`void`	`neighbors(java.util.Vector<java.lang.Integer> v)`	Computes a vector list of neighbors.
`void`	`normals(java.util.Vector<java.lang.Double> v)`	This routine calculates the unit normal vectors for every face.
`private void`	`normals_search(java.util.Vector<java.lang.Double> v, int i, int j, int k)`	This inline routine is called by normals().
`boolean`	`nplane(Voro.voronoicell_neighbor vc, double x, double y, double z, double rsq, int p_id)`
`boolean`	`nplane(Voro.voronoicell vc, double x, double y, double z, double rsq, int p_id)`	Cuts the Voronoi cell by a particle whose center is at a separation of (x,y,z) from the cell center.
`int`	`number_of_edges()`	Counts the number of edges of the Voronoi cell.
`int`	`number_of_faces()`	Returns the number of faces of a computed Voronoi cell.
`void`	`output_custom(char[] format, int i, double x, double y, double z, double r, java.io.RandomAccessFile raFile)`	Outputs a custom string of information about the Voronoi cell.
`void`	`output_custom(char[] format, java.io.RandomAccessFile raFile)`	Outputs a custom string of information about the Voronoi cell to a file.
`void`	`output_face_areas()`
`void`	`output_face_areas(java.io.RandomAccessFile raFile)`	Outputs the areas of the faces.
`void`	`output_face_freq_table()`
`void`	`output_face_freq_table(java.io.RandomAccessFile raFile)`	Outputs a
`void`	`output_face_orders()`
`void`	`output_face_orders(java.io.RandomAccessFile raFile)`	Outputs a list of the number of sides of each face.
`void`	`output_face_perimeters()`
`void`	`output_face_perimeters(java.io.RandomAccessFile raFile)`	Outputs a list of the perimeters of each face.
`void`	`output_face_vertices()`
`void`	`output_face_vertices(java.io.RandomAccessFile raFile)`	Outputs the
`void`	`output_normals()`
`void`	`output_normals(java.io.RandomAccessFile raFile)`	Outputs a list of the perimeters of each face.
`void`	`output_solid_angles(java.io.RandomAccessFile raFile)`	Outputs the solid angles of the faces.
`void`	`output_vertex_orders()`
`void`	`output_vertex_orders(java.io.RandomAccessFile raFile)`	Outputs the vertex orders.
`void`	`output_vertices()`
`void`	`output_vertices(double x, double y, double z, java.io.RandomAccessFile raFile)`	Outputs the vertex vectors using the global coordinate system.
`void`	`output_vertices(java.io.RandomAccessFile raFile)`	Outputs the vertex vectors using the local coordinate system.
`boolean`	`plane_intersects(double x, double y, double z, double rsq)`	This routine tests to see whether the cell intersects a plane by starting from the guess point up.
`boolean`	`plane_intersects_guess(double x, double y, double z, double rsq)`	This routine tests to see if a cell intersects a plane.
`private boolean`	`plane_intersects_track(double x, double y, double z, double rsq, double g)`
`void`	`print_edges()`	Prints the vertices, their edges, the relation table, and also notifies if any memory errors are visible.
`protected void`	`reset_edges()`	Several routines in the class that gather cell-based statistics internally track their progress by flipping edges to negative so that they know what parts of the cell have already been tested.
`private void`	`reset_mask()`
`private boolean`	`search_downward(int[] lw, int[] lp, int[] ls, int[] us, double[] l, double[] u)`
`private boolean`	`search_edge(int l, int[] m, int[] k)`
`private boolean`	`search_for_outside_edge(int[] up)`	Starting from a point within the current cutting plane, this routine attempts to find an edge to a point outside the cutting plane.
`private boolean`	`search_upward(int[] uw, int[] lp, int[] ls, int[] us, double[] l, double[] u)`	Assuming that the point up is outside the cutting plane, this routine searches upwards along edges trying to find an edge that intersects the cutting plane.
`void`	`solid_angles(java.util.Vector<java.lang.Double> v)`	Calculates the solid angles of each face of the Voronoi cell and prints the results to an output stream.
`double`	`surface_area()`	Calculates the total surface area of the Voronoi cell.
`double`	`total_edge_distance()`	Calculates the total edge distance of the Voronoi cell.
`void`	`translate(double x, double y, double z)`	Translates the vertices of the Voronoi cell by a given vector.
`void`	`vertex_orders(java.util.Vector<java.lang.Integer> v)`	Returns a vector of the vertex orders.
`void`	`vertices(double x, double y, double z, java.util.Vector<java.lang.Double> v)`	Returns a vector of the vertex vectors in the global coordinate system.
`void`	`vertices(java.util.Vector<java.lang.Double> v)`	Returns a vector of the vertex vectors using the local coordinate system.
`double`	`volume()`	Calculates the volume of the Voronoi cell, by decomposing the cell into tetrahedra extending outward from the zeroth vertex, whose volumes are evaluated using a scalar triple product.

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

- Field Detail
  - current_vertices
```
public int current_vertices
```
    This holds the current size of the arrays ed and nu, which hold the vertex information. If more vertices are created than can fit in this array, then it is dynamically extended using the add_memory_vertices routine.
  - current_vertex_order
```
public int current_vertex_order
```
    This holds the current maximum allowed order of a vertex, which sets the size of the mem, mep, and mec arrays. If a vertex is created with more vertices than this, the arrays are dynamically extended using the add_memory_vorder routine.
  - current_delete_size
```
public int current_delete_size
```
    This sets the size of the main delete stack.
  - current_delete2_size
```
public int current_delete2_size
```
    This sets the size of the auxiliary delete stack.
  - current_xsearch_size
```
public int current_xsearch_size
```
    This sets the size of the extra search stack.
  - p
```
public int p
```
    This sets the total number of vertices in the current cell.
  - up
```
public int up
```
    This is the index of particular point in the cell, which is used to start the tracing routines for plane intersection and cutting. These routines will work starting from any point, but it's often most efficient to start from the last point considered, since in many cases, the cell construction algorithm may consider many planes with similar vectors concurrently.
  - ed
```
public int[] ed
```
    This is a two dimensional array that holds information about the edge connections of the vertices that make up the cell. The two dimensional array is not allocated in the usual method. To account for the fact the different vertices have different orders, and thus require different amounts of storage, the elements of ed[i] point to one-dimensional arrays in the mep[] array of different sizes. More specifically, if vertex i has order m, then ed[i] points to a one-dimensional array in mep[m] that has 2*m+1 entries. The first m elements hold the neighboring edges, so that the jth edge of vertex i is held in ed[i][j]. The next m elements hold a table of relations which is redundant but helps speed up the computation. It satisfies the relation ed[ed[i][j]][ed[i][m+j]]=i. The final entry holds a back pointer, so that ed[i+2*m]=i. The back pointers are used when rearranging the memory.
  - nu
```
public int[] nu
```
    This array holds the order of the vertices in the Voronoi cell. This array is dynamically allocated, with its current size held by current_vertices.
  - mask
```
public int[] mask
```
  - pts
```
public double[] pts
```
    This in an array with size 3*current_vertices for holding the positions of the vertices.
  - tol
```
public double tol
```
  - tol_cu
```
public double tol_cu
```
  - big_tol
```
public double big_tol
```
  - mem
```
protected int[] mem
```
    This a one dimensional array that holds the current sizes of the memory allocations for them mep array.
  - mec
```
protected int[] mec
```
    This is a one dimensional array that holds the current number of vertices of order p that are stored in the mep[p] array.
  - mep
```
protected int[][] mep
```
    This is a two dimensional array for holding the information about the edges of the Voronoi cell. mep[p] is a one-dimensional array for holding the edge information about all vertices of order p, with each vertex holding 2*p+1 integers of information. The total number of vertices held on mep[p] is stored in mem[p]. If the space runs out, the code allocates more using the add_memory() routine.
  - q
```
protected int[] q
```
  - edmep
```
protected int[] edmep
```
  - mne
```
public int[][] mne
```
    This two dimensional array holds the neighbor information associated with each vertex. mne[p] is a one dimensional array which holds all of the neighbor information for vertices of order p.
  - ne
```
public int[] ne
```
    This is a two dimensional array that holds the neighbor information associated with each vertex. ne[i] points to a one-dimensional array in mne[nu[i]]. ne[i][j] holds the neighbor information associated with the jth edge of vertex i. It is set to the ID number of the plane that made the face that is clockwise from the jth edge.
  - nemne
```
public int[] nemne
```
  - ds
```
private int[] ds
```
    This is the delete stack, used to store the vertices which are going to be deleted during the plane cutting procedure.
  - stackp_index
```
int stackp_index
```
  - stacke_index
```
int stacke_index
```
  - ds2
```
private int[] ds2
```
    This is the auxiliary delete stack, which has size set by current_delete2_size.
  - stackp2_index
```
int stackp2_index
```
  - stacke2_index
```
int stacke2_index
```
  - xse
```
private int[] xse
```
    This is the extra search stack.
  - stackp3_index
```
int stackp3_index
```
  - stacke3_index
```
int stacke3_index
```
  - maskc
```
private int maskc
```
  - px
```
private double px
```
    The x coordinate of the normal vector to the test plane.
  - py
```
private double py
```
    The y coordinate of the normal vector to the test plane.
  - pz
```
private double pz
```
    The z coordinate of the normal vector to the test plane.
  - prsq
```
private double prsq
```
    The magnitude of the normal vector to the test plane.
- Constructor Detail
  - voronoicell_base
```
public voronoicell_base(double max_len_sq)
```
    Constructs a Voronoi cell and sets up the initial memory.
- Method Detail
  - delete
```
public void delete()
```
    The voronoicell destructor deallocates all the dynamic memory.
  - init_base
```
public void init_base(double xmin,
                      double xmax,
                      double ymin,
                      double ymax,
                      double zmin,
                      double zmax)
```
    Initializes a Voronoi cell as a rectangular box with the given dimensions. \param[in] (xmin,xmax) the minimum and maximum x coordinates. \param[in] (ymin,ymax) the minimum and maximum y coordinates. \param[in] (zmin,zmax) the minimum and maximum z coordinates.
  - init_octahedron_base
```
public void init_octahedron_base(double l)
```
    Initializes a Voronoi cell as a regular octahedron. \param[in] l The distance from the octahedron center to a vertex. Six vertices are initialized at (-l,0,0), (l,0,0), (0,-l,0), (0,l,0), (0,0,-l), and (0,0,l).
  - init_tetrahedron_base
```
public void init_tetrahedron_base(double x0,
                                  double y0,
                                  double z0,
                                  double x1,
                                  double y1,
                                  double z1,
                                  double x2,
                                  double y2,
                                  double z2,
                                  double x3,
                                  double y3,
                                  double z3)
```
    Initializes a Voronoi cell as a tetrahedron. It assumes that the normal to the face for the first three vertices points inside. \param (x0,y0,z0) a position vector for the first vertex. \param (x1,y1,z1) a position vector for the second vertex. \param (x2,y2,z2) a position vector for the third vertex. \param (x3,y3,z3) a position vector for the fourth vertex.
  - translate
```
public void translate(double x,
                      double y,
                      double z)
```
    Translates the vertices of the Voronoi cell by a given vector. \param[in] (x,y,z) the coordinates of the vector.
  - draw_pov
```
public void draw_pov(double x,
                     double y,
                     double z,
                     java.io.RandomAccessFile raFile)
```
    Outputs the edges of the Voronoi cell in POV-Ray format to an open file stream, displacing the cell by given vector. \param[in] (x,y,z) a displacement vector to be added to the cell's position. \param[in] fp a file handle to write to.
  - draw_pov
```
public void draw_pov(double x,
                     double y,
                     double z,
                     java.lang.String filename)
```
    Outputs the cell in POV-Ray format, using cylinders for edges and spheres for vertices, to a given file. \param[in] (x,y,z) a displacement to add to the cell's position. \param[in] filename the name of the file to write to.
  - draw_pov_mesh
```
public void draw_pov_mesh(double x,
                          double y,
                          double z,
                          java.io.RandomAccessFile raFile)
```
    Outputs the Voronoi cell in the POV mesh2 format, described in section 1.3.2.2 of the POV-Ray documentation. The mesh2 output consists of a list of vertex vectors, followed by a list of triangular faces. The routine also makes use of the optional inside_vector specification, which makes the mesh object solid, so that the POV-Ray Constructive Solid Geometry (CSG) can be applied. \param[in] (x,y,z) a displacement vector to be added to the cell's position. \param[in] fp a file handle to write to.
  - draw_pov_mesh
```
public void draw_pov_mesh(double x,
                          double y,
                          double z,
                          java.lang.String filename)
```
    Outputs the cell in POV-Ray format as a mesh2 object to a given file. \param[in] (x,y,z) a displacement to add to the cell's position. \param[in] filename the name of the file to write to.
  - draw_gnuplot
```
public void draw_gnuplot(double x,
                         double y,
                         double z,
                         java.io.RandomAccessFile raFile)
```
    Outputs the edges of the Voronoi cell in gnuplot format to an output stream. \param[in] (x,y,z) a displacement vector to be added to the cell's position. \param[in] fp a file handle to write to.
  - draw_gnuplot
```
public void draw_gnuplot(double x,
                         double y,
                         double z,
                         java.lang.String filename)
```
    Outputs the cell in Gnuplot format a given file. \param[in] (x,y,z) a displacement to add to the cell's position. \param[in] filename the name of the file to write to.
  - volume
```
public double volume()
```
    Calculates the volume of the Voronoi cell, by decomposing the cell into tetrahedra extending outward from the zeroth vertex, whose volumes are evaluated using a scalar triple product. \return A floating point number holding the calculated volume.
  - max_radius_squared
```
public double max_radius_squared()
```
    Computes the maximum radius squared of a vertex from the center of the cell. It can be used to determine when enough particles have been testing an all planes that could cut the cell have been considered. \return The maximum radius squared of a vertex.
  - total_edge_distance
```
public double total_edge_distance()
```
    Calculates the total edge distance of the Voronoi cell. \return A floating point number holding the calculated distance.
  - surface_area
```
public double surface_area()
```
    Calculates the total surface area of the Voronoi cell. \return The computed area.
  - centroid
```
public void centroid(double[] cx,
                     double[] cy,
                     double[] cz)
```
    Calculates the centroid of the Voronoi cell, by decomposing the cell into tetrahedra extending outward from the zeroth vertex. \param[out] (cx,cy,cz) references to floating point numbers in which to pass back the centroid vector.
  - number_of_faces
```
public int number_of_faces()
```
    Returns the number of faces of a computed Voronoi cell. \return The number of faces.
  - number_of_edges
```
public int number_of_edges()
```
    Counts the number of edges of the Voronoi cell. \return the number of edges.
  - vertex_orders
```
public void vertex_orders(java.util.Vector<java.lang.Integer> v)
```
    Returns a vector of the vertex orders. \param[out] v the vector to store the results in.
  - output_vertex_orders
```
public void output_vertex_orders(java.io.RandomAccessFile raFile)
```
    Outputs the vertex orders. \param[out] fp the file handle to write to.
  - output_vertex_orders
```
public void output_vertex_orders()
```
  - vertices
```
public void vertices(java.util.Vector<java.lang.Double> v)
```
    Returns a vector of the vertex vectors using the local coordinate system. \param[out] v the vector to store the results in.
  - output_vertices
```
public void output_vertices(java.io.RandomAccessFile raFile)
```
    Outputs the vertex vectors using the local coordinate system. \param[out] fp the file handle to write to.
  - output_vertices
```
public void output_vertices()
```
  - vertices
```
public void vertices(double x,
                     double y,
                     double z,
                     java.util.Vector<java.lang.Double> v)
```
    Returns a vector of the vertex vectors in the global coordinate system. \param[out] v the vector to store the results in. \param[in] (x,y,z) the position vector of the particle in the global coordinate system.
  - output_vertices
```
public void output_vertices(double x,
                            double y,
                            double z,
                            java.io.RandomAccessFile raFile)
```
    Outputs the vertex vectors using the global coordinate system. \param[out] fp the file handle to write to. \param[in] (x,y,z) the position vector of the particle in the global coordinate system.
  - solid_angles
```
public void solid_angles(java.util.Vector<java.lang.Double> v)
```
    Calculates the solid angles of each face of the Voronoi cell and prints the results to an output stream. \param[out] v the vector to store the results in.
  - face_areas
```
public void face_areas(java.util.Vector<java.lang.Double> v)
```
    Calculates the areas of each face of the Voronoi cell and prints the results to an output stream. \param[out] v the vector to store the results in.
  - minkowski
```
public void minkowski(double r,
                      double[] ar,
                      double[] vo)
```
    Calculates the contributions to the Minkowski functionals for this Voronoi cell. \param[in] r the radius to consider. \param[out] ar the area functional. \param[out] vo the volume functional.
  - output_solid_angles
```
public void output_solid_angles(java.io.RandomAccessFile raFile)
```
    Outputs the solid angles of the faces. \param[in] fp the file handle to write to.
  - output_face_areas
```
public void output_face_areas(java.io.RandomAccessFile raFile)
```
    Outputs the areas of the faces. \param[in] fp the file handle to write to.
  - output_face_areas
```
public void output_face_areas()
```
  - face_orders
```
public void face_orders(java.util.Vector<java.lang.Integer> v)
```
    Outputs a list of the number of edges in each face. \param[out] v the vector to store the results in.
  - output_face_orders
```
public void output_face_orders(java.io.RandomAccessFile raFile)
```
    Outputs a list of the number of sides of each face. \param[in] fp the file handle to write to.
  - output_face_orders
```
public void output_face_orders()
```
  - face_freq_table
```
public void face_freq_table(java.util.Vector<java.lang.Integer> v)
```
    Computes the number of edges that each face has and outputs a frequency table of the results. \param[out] v the vector to store the results in.
  - output_face_freq_table
```
public void output_face_freq_table(java.io.RandomAccessFile raFile)
```
    Outputs a
  - output_face_freq_table
```
public void output_face_freq_table()
```
  - face_vertices
```
public void face_vertices(java.util.Vector<java.lang.Integer> v)
```
    For each face, this routine outputs a bracketed sequence of numbers containing a list of all the vertices that make up that face. \param[out] v the vector to store the results in.
  - output_face_vertices
```
public void output_face_vertices(java.io.RandomAccessFile raFile)
```
    Outputs the
  - output_face_vertices
```
public void output_face_vertices()
```
  - face_perimeters
```
public void face_perimeters(java.util.Vector<java.lang.Double> v)
```
    This routine returns the perimeters of each face. \param[out] v the vector to store the results in.
  - output_face_perimeters
```
public void output_face_perimeters(java.io.RandomAccessFile raFile)
```
    Outputs a list of the perimeters of each face. \param[in] fp the file handle to write to.
  - output_face_perimeters
```
public void output_face_perimeters()
```
  - normals
```
public void normals(java.util.Vector<java.lang.Double> v)
```
    This routine calculates the unit normal vectors for every face. \param[out] v the vector to store the results in.
  - output_normals
```
public void output_normals(java.io.RandomAccessFile raFile)
```
    Outputs a list of the perimeters of each face. \param[in] fp the file handle to write to.
  - output_normals
```
public void output_normals()
```
  - output_custom
```
public void output_custom(char[] format,
                          java.io.RandomAccessFile raFile)
```
    Outputs a custom string of information about the Voronoi cell to a file. It assumes the cell is at (0,0,0) and has a the default_radius associated with it. \param[in] format the custom format string to use. \param[in] fp the file handle to write to.
  - output_custom
```
public void output_custom(char[] format,
                          int i,
                          double x,
                          double y,
                          double z,
                          double r,
                          java.io.RandomAccessFile raFile)
```
    Outputs a custom string of information about the Voronoi cell. The string of information follows a similar style as the C printf command, and detailed information about its format is available at http://math.lbl.gov/voro++/doc/custom.html. \param[in] format the custom string to print. \param[in] i the ID of the particle associated with this Voronoi cell. \param[in] (x,y,z) the position of the particle associated with this Voronoi cell. \param[in] r a radius associated with the particle. \param[in] fp the file handle to write to.
  - nplane
```
public boolean nplane(Voro.voronoicell vc,
                      double x,
                      double y,
                      double z,
                      double rsq,
                      int p_id)
```
    Cuts the Voronoi cell by a particle whose center is at a separation of (x,y,z) from the cell center. The value of rsq should be initially set to \f$x^2+y^2+z^2\f$. \param[in] vc a reference to the specialized version of the calling class. \param[in] (x,y,z) the normal vector to the plane. \param[in] rsq the distance along this vector of the plane. \param[in] p_id the plane ID (for neighbor tracking only). \return False if the plane cut deleted the cell entirely, true otherwise.
  - nplane
```
public boolean nplane(Voro.voronoicell_neighbor vc,
                      double x,
                      double y,
                      double z,
                      double rsq,
                      int p_id)
```
  - plane_intersects
```
public boolean plane_intersects(double x,
                                double y,
                                double z,
                                double rsq)
```
    This routine tests to see whether the cell intersects a plane by starting from the guess point up. If up intersects, then it immediately returns true. Otherwise, it calls the plane_intersects_track() routine. \param[in] (x,y,z) the normal vector to the plane. \param[in] rsq the distance along this vector of the plane. \return False if the plane does not intersect the plane, true if it does.
  - plane_intersects_guess
```
public boolean plane_intersects_guess(double x,
                                      double y,
                                      double z,
                                      double rsq)
```
    This routine tests to see if a cell intersects a plane. It first tests a random sample of approximately sqrt(p)/4 points. If any of those are intersect, then it immediately returns true. Otherwise, it takes the closest point and passes that to plane_intersect_track() routine. \param[in] (x,y,z) the normal vector to the plane. \param[in] rsq the distance along this vector of the plane. \return False if the plane does not intersect the plane, true if it does.
  - construct_relations
```
public void construct_relations()
```
    Constructs the relational table if the edges have been specified.
  - check_relations
```
public void check_relations()
```
    Checks that the relational table of the Voronoi cell is accurate, and prints out any errors. This algorithm is O(p), so running it every time the plane routine is called will result in a significant slowdown.
  - edc
```
public int edc(int i,
               int j)
```
  - check_duplicates
```
public void check_duplicates()
```
    This routine checks for any two vertices that are connected by more than one edge. The plane algorithm is designed so that this should not happen, so any occurrences are most likely errors. Note that the routine is O(p), so running it every time the plane routine is called will result in a significant slowdown.
  - print_edges
```
public void print_edges()
```
    Prints the vertices, their edges, the relation table, and also notifies if any memory errors are visible.
  - cycle_up
```
public int cycle_up(int a,
                    int p)
```
    This is a simple inline function for picking out the index of the next edge counterclockwise at the current vertex. \param[in] a the index of an edge of the current vertex. \param[in] p the number of the vertex. \return 0 if a=nu[p]-1, or a+1 otherwise.
  - cycle_down
```
public int cycle_down(int a,
                      int p)
```
    This is a simple inline function for picking out the index of the next edge clockwise from the current vertex. \param[in] a the index of an edge of the current vertex. \param[in] p the number of the vertex. \return nu[p]-1 if a=0, or a-1 otherwise.
  - reset_edges
```
protected void reset_edges()
```
    Several routines in the class that gather cell-based statistics internally track their progress by flipping edges to negative so that they know what parts of the cell have already been tested. This function resets them back to positive. When it is called, it assumes that every edge in the routine should have already been flipped to negative, and it bails out with an internal error if it encounters a positive edge.
  - check_memory_for_copy
```
protected void check_memory_for_copy(Voro.voronoicell vc,
                                     Voro.voronoicell_base vb)
```
  - check_memory_for_copy
```
protected void check_memory_for_copy(Voro.voronoicell_neighbor vc,
                                     Voro.voronoicell_base vb)
```
  - copy
```
protected void copy(Voro.voronoicell_base vb)
```
    Copies the vertex and edge information from another class. The routine assumes that enough memory is available for the copy. \param[in] vb a pointer to the class to copy.
  - add_memory
```
private void add_memory(Voro.voronoicell vc,
                        int i)
```
    Increases the memory storage for a particular vertex order, by increasing the size of the of the corresponding mep array. If the arrays already exist, their size is doubled; if they don't exist, then new ones of size init_n_vertices are allocated. The routine also ensures that the pointers in the ed array are updated, by making use of the back pointers. For the cases where the back pointer has been temporarily overwritten in the marginal vertex code, the auxiliary delete stack is scanned to find out how to update the ed value. If the template has been instantiated with the neighbor tracking turned on, then the routine also reallocates the corresponding mne array. \param[in] i the order of the vertex memory to be increased.
  - add_memory
```
private void add_memory(Voro.voronoicell_neighbor vc,
                        int i)
```
  - add_memory_vertices
```
private void add_memory_vertices(Voro.voronoicell vc)
```
    Doubles the maximum number of vertices allowed, by reallocating the ed, nu, and pts arrays. If the allocation exceeds the absolute maximum set in max_vertices, then the routine exits with a fatal error. If the template has been instantiated with the neighbor tracking turned on, then the routine also reallocates the ne array.
  - add_memory_vertices
```
private void add_memory_vertices(Voro.voronoicell_neighbor vc)
```
  - add_memory_vorder
```
private void add_memory_vorder(Voro.voronoicell vc)
```
    Doubles the maximum allowed vertex order, by reallocating mem, mep, and mec arrays. If the allocation exceeds the absolute maximum set in max_vertex_order, then the routine causes a fatal error. If the template has been instantiated with the neighbor tracking turned on, then the routine also reallocates the mne array.
  - add_memory_vorder
```
private void add_memory_vorder(Voro.voronoicell_neighbor vc)
```
  - add_memory_ds
```
private void add_memory_ds()
```
    Doubles the size allocation of the main delete stack. If the allocation exceeds the absolute maximum set in max_delete_size, then routine causes a fatal error.
  - add_memory_ds2
```
private void add_memory_ds2()
```
    Doubles the size allocation of the auxiliary delete stack. If the allocation exceeds the absolute maximum set in max_delete2_size, then the routine causes a fatal error.
  - add_memory_xse
```
private void add_memory_xse()
```
    Doubles the size allocation of the auxiliary delete stack. If the allocation exceeds the absolute maximum set in max_delete2_size, then the routine causes a fatal error.
  - create_facet
```
private boolean create_facet(Voro.voronoicell vc,
                             int lp,
                             int ls,
                             double l,
                             int us,
                             double u,
                             int p_id)
```
    Creates a new facet. \return True if cell deleted, false otherwise.
  - create_facet
```
private boolean create_facet(Voro.voronoicell_neighbor vc,
                             int lp,
                             int ls,
                             double l,
                             int us,
                             double u,
                             int p_id)
```
  - collapse_order1
```
private boolean collapse_order1(Voro.voronoicell vc)
```
    Order one vertices can potentially be created during the order two collapse routine. This routine keeps removing them until there are none left. \return False if the vertex removal was unsuccessful, indicative of the cell having zero volume and disappearing; true if the vertex removal was successful.
  - collapse_order1
```
private boolean collapse_order1(Voro.voronoicell_neighbor vc)
```
  - collapse_order2
```
private boolean collapse_order2(Voro.voronoicell vc)
```
    During the creation of a new facet in the plane routine, it is possible that some order two vertices may arise. This routine removes them. Suppose an order two vertex joins c and d. If there's a edge between c and d already, then the order two vertex is just removed; otherwise, the order two vertex is removed and c and d are joined together directly. It is possible this process will create order two or order one vertices, and the routine is continually run until all of them are removed. \return False if the vertex removal was unsuccessful, indicative of the cell reducing to zero volume and disappearing; true if the vertex removal was successful.
  - collapse_order2
```
private boolean collapse_order2(Voro.voronoicell_neighbor vc)
```
  - delete_connection
```
private boolean delete_connection(Voro.voronoicell vc,
                                  int j,
                                  int k,
                                  boolean hand)
```
    This routine deletes the kth edge of vertex j and reorganizes the memory. If the neighbor computation is enabled, we also have to supply an handedness flag to decide whether to preserve the plane on the left or right of the connection. \return False if a zero order vertex was formed, indicative of the cell disappearing; true if the vertex removal was successful.
  - delete_connection
```
private boolean delete_connection(Voro.voronoicell_neighbor vc,
                                  int j,
                                  int k,
                                  boolean hand)
```
  - search_for_outside_edge
```
private boolean search_for_outside_edge(int[] up)
```
    Starting from a point within the current cutting plane, this routine attempts to find an edge to a point outside the cutting plane. This prevents the plane routine from . \param[in,out] up
  - add_to_stack
```
private void add_to_stack(int sc2,
                          int lp)
```
    Adds a point to the auxiliary delete stack if it is not already there. \param[in] vc a reference to the specialized version of the calling class. \param[in] lp the index of the point to add. \param[in,out] stackp2 a pointer to the end of the stack entries.
  - reset_mask
```
private void reset_mask()
```
  - search_downward
```
private boolean search_downward(int[] lw,
                                int[] lp,
                                int[] ls,
                                int[] us,
                                double[] l,
                                double[] u)
```
  - definite_max
```
private boolean definite_max(int[] lp,
                             int[] ls,
                             double[] l,
                             double[] u,
                             int[] uw)
```
    Checks whether a particular point lp is a definite maximum, searching through any possible minor non-convexities, for a better maximum. \param[in] (x,y,z) the normal vector to the plane.
  - search_upward
```
private boolean search_upward(int[] uw,
                              int[] lp,
                              int[] ls,
                              int[] us,
                              double[] l,
                              double[] u)
```
    Assuming that the point up is outside the cutting plane, this routine searches upwards along edges trying to find an edge that intersects the cutting plane. \param[in] rsq the distance along this vector of the plane. \param[in,out] u the dot product of point up with the normal. \return True if the cutting plane was reached, false otherwise.
  - definite_min
```
private boolean definite_min(int[] lp,
                             int[] us,
                             double[] l,
                             double[] u,
                             int[] lw)
```
  - minkowski_contrib
```
private void minkowski_contrib(int i,
                               int k,
                               int m,
                               double r,
                               double[] ar,
                               double[] vo)
```
  - minkowski_edge
```
private void minkowski_edge(double x0,
                            double r1,
                            double s1,
                            double r2,
                            double s2,
                            double r,
                            double[] ar,
                            double[] vo)
```
  - minkowski_formula
```
private void minkowski_formula(double x0,
                               double y0,
                               double z0,
                               double r,
                               double[] ar,
                               double[] vo)
```
  - plane_intersects_track
```
private boolean plane_intersects_track(double x,
                                       double y,
                                       double z,
                                       double rsq,
                                       double g)
```
  - normals_search
```
private void normals_search(java.util.Vector<java.lang.Double> v,
                            int i,
                            int j,
                            int k)
```
    This inline routine is called by normals(). It attempts to construct a single normal vector that is associated with a particular face. It first traces around the face, trying to find two vectors along the face edges whose vector product is above the numerical tolerance. It then constructs the normal vector using this product. If the face is too small, and none of the vector products are large enough, the routine may return (0,0,0) as the normal vector. \param[in] v the vector to store the results in. \param[in] i the initial vertex of the face to test. \param[in] j the index of an edge of the vertex. \param[in] k the neighboring vertex of i, set to ed[i][j].
  - search_edge
```
private boolean search_edge(int l,
                            int[] m,
                            int[] k)
```
  - m_test
```
private int m_test(int n,
                   double[] ans)
```
    Checks to see if a given vertex is inside, outside or within the test plane. If the point is far away from the test plane, the routine immediately returns whether it is inside or outside. If the routine is close the the plane and within the specified tolerance, then the special check_marginal() routine is called. \param[in] n the vertex to test. \param[out] ans the result of the scalar product used in evaluating the location of the point. \return -1 if the point is inside the plane, 1 if the point is outside the plane, or 0 if the point is within the plane.
  - m_testx
```
private int m_testx(int n,
                    double[] ans)
```
    Checks to see if a given vertex is inside, outside or within the test plane. If the point is far away from the test plane, the routine immediately returns whether it is inside or outside. If the routine is close the the plane and within the specified tolerance, then the special check_marginal() routine is called. \param[in] n the vertex to test. \param[out] ans the result of the scalar product used in evaluating the location of the point. \return -1 if the point is inside the plane, 1 if the point is outside the plane, or 0 if the point is within the plane.
  - m_calc
```
private int m_calc(int n,
                   double[] ans)
```
  - flip
```
private void flip(int tp)
```
  - neighbors
```
public void neighbors(java.util.Vector<java.lang.Integer> v)
```
    Computes a vector list of neighbors.

Class Voro.voronoicell_base

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

current_vertices

current_vertex_order

current_delete_size

current_delete2_size

current_xsearch_size

p

up

ed

nu

mask

pts

tol

tol_cu

big_tol

mem

mec

mep

q

edmep

mne

ne

nemne

ds

stackp_index

stacke_index

ds2

stackp2_index

stacke2_index

xse

stackp3_index

stacke3_index

maskc

px

py

pz

prsq

Constructor Detail

voronoicell_base

Method Detail

delete

init_base

init_octahedron_base

init_tetrahedron_base

translate

draw_pov

draw_pov

draw_pov_mesh

draw_pov_mesh

draw_gnuplot

draw_gnuplot

volume

max_radius_squared

total_edge_distance

surface_area

centroid

number_of_faces

number_of_edges

vertex_orders

output_vertex_orders

output_vertex_orders

vertices

output_vertices

output_vertices

vertices

output_vertices

solid_angles

face_areas

minkowski

output_solid_angles

output_face_areas

output_face_areas

face_orders

output_face_orders

output_face_orders