DepthMap class

package edu.ufl.digitalworlds.j4k;

public class DepthMap {

    /*This method constructs a default DepthMap of a given size*/
    public DepthMap(int w, int h);

    /*This method constructs a DepthMap out of a depth frame received 
         from a Kinect sensor and is given as an XYZ array.*/
    public DepthMap(int w, int h, float XYZ[]);

    /*This method returns the width of the DepthMap (in pixels).*/
    public int getWidth();

    /*This method returns the height of the DepthMap (in pixels).*/
    public int getHeight();
    
    /*This method returns true if there is a non-zero depth value at
      the pixel (x,y).*/
    public boolean validDepthAt(int x, int y);

    /*This method returns true if there is a non-zero depth value at
         the pixel location (x,y) given as index=y*width+x.*/
    public boolean validDepthAt(int index);

    /*This method displays the DepthMap as a 3D surface.  The U,V 
      texture coordinates are used, if available, otherwise the 
      normal vectors of the 3D surface are computed for shading 
      purposes. This method requires the JOGL Java library.*/
    public void draw(GL2 gl);
    
    /*This method displays the DepthMap as a 3D surface by skipping
      every 'skip' pixels in both dimensions. The U,V texture 
      coordinates are used, if available, otherwise, the normal 
      vectors of the 3D surface are computed for shading purposes.
      This method requires the JOGL Java library.*/
    public void draw(GL2 gl,int skip);

    /*This method displays the DepthMap as a 3D surface. The normal 
         vectors of the 3D surface are computed for shading purposes. 
      This method requires the JOGL Java library.*/
    public void drawNormals(GL2 gl);
    
    /*This method displays the DepthMap as a 3D surface by skipping
      every 'skip' pixels in both dimensions. The normal vectors of 
      the 3D surface are computed for shading purposes. This method 
      requires the JOGL Java library.*/
    public void drawNormals(GL2 gl,int skip);
    
    /*This method displays the DepthMap as a 3D surface using the 
      U,V texture coordinates, if available. This method requires 
      the JOGL Java library.*/
    public void drawTexture(GL2 gl);
    
    /*This method displays the DepthMap as a 3D surface by skipping
      every 'skip' pixels in both dimensions. The U,V texture 
      coordinates are used, if available. This method requires the 
      JOGL Java library.*/
    public void drawTexture(GL2 gl,int skip);
    
    /*This method displays the DepthMap as a 3D surface. The normal 
         vectors of the 3D surface are computed for shading purposes. 
      The U,V texture coordinates are also used, if available. This
      method requires the JOGL Java library.*/
    public void drawTextureNormals(GL2 gl);    
    
    /*This method displays the DepthMap as a 3D surface by skipping
      every 'skip' pixels in both dimensions. The normal vectors of 
      the 3D surface are computed for shading purposes. The U,V 
      texture coordinates are also used, if available. This method 
      requires the JOGL Java library.*/
    public void drawTextureNormals(GL2 gl,int skip);

    /*This method displays the DepthMap as a 3D rectangular grid.
      The normal vectors are computed for shading purposes. This 
      method requires the JOGL Java library.*/
    public void drawMesh(GL2 gl);

    /*This method displays the DepthMap as a 3D rectangular grid by
         skipping every 'skip' pixels in both dimensions. The normal 
         vectors are computed for shading purposes. This method 
      requires the JOGL Java library.*/
    public void drawMesh(GL2 gl, int skip);

    /*With this method you can provide a U,V texture mapping in the
      form of float array that hold pixel locations in an image.*/ 
    public void setUV(float[] UV);
    
    /*This method creates a uniform U,V texture mapping for this 
      DepthMap.*/
    public void setUVuniform();

    /*This method sets the player index for this DepthMap.*/
    public void setPlayerIndex(short[] depth_frame, byte[] player_index);

    /*With this method you can specify the maximum allowed difference 
      in depth values within a quad. If a quad does not satisfy this 
      criterion it is not rendered.*/
    public void setMaximumAllowedDeltaZ(double dz);

    /*This method returns the current maximum allowed difference in 
      depth values within a quad.*/     
    public float getMaximumAllowedDeltaZ();

    /*This method masks out all pixels with depth value larger than
      a given threshold.*/
    public void maskZ(float threshold);

    /*This method masks out all pixels outside the rectange defined
      by a given corner point (x,y) and of size width x height.*/
    public void maskRect(int x, int y, int width, int height);

    /*This method performs smoothing of the depth frame.*/
    public void smooth();

    /*This method repeats the smoothing process for several times.*/
    public void smooth(int times);

    /*This method exports the DepthMap in VRML (wrl) format.*/
    public void saveWRL(String filename);
    
    /*This method exports the DepthMap in VRML (wrl) format by 
      skipping every 'skip' pixels in both dimensions.*/
    public void saveWRL(String filename, int skip)        

    /*The following public arrays contain the parameters of the 
      DepthMap. You can directly read or write to these arrays to
      alter the DepthMap in your custom algorithms.*/ 
    public float realX[]=null;
    public float realY[]=null;
    public float realZ[]=null;

    public float U[]=null;
    public float V[]=null;
    
    /*The player array provides a player ID at each pixel of the
      DepthMap. The playerID information is included in the packed
      depth frames received from the Kinect.*/
    public byte player[]=null;
    
    public boolean mask[]=null;

    /*You can provide a 4x4 transformation matrix to be applied to the
      DepthMap. The transformation should be given in a 1D array form
      arranged by columns.*/
    public double transformation[];    
}