Package com.metsci.glimpse.core.support.projection

Class GenericProjection

  • All Implemented Interfaces:
    Projection
    public class GenericProjection
extends Object
implements Projection
    An alternative means of specifying a general projection. The cleanest method is to implement Projection (and possibly InvertibleProjection) and manually calculate the texture fraction and vertex coordinates for any given inputs. GenericProjection instead allows the vertices of the projection to be directly specified.
    Author:
    ulman

    • Constructor Summary

      Constructors 
      Constructor Description
      GenericProjection​(double[][] coordsX, double[][] coordsY)  

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      int getSizeX​(int textureSizeX)
      Returns the number of quads in the x direction that the array of data (the texture) should be broken into.
      int getSizeY​(int textureSizeY)  
      void getVertexXY​(double dataFractionX, double dataFractionY, float[] resultXY)
      Given a position in a rectangular array of data (the texture), return the corresponding location in physical units.
      void getVertexXYZ​(double textureFractionX, double textureFractionY, float[] resultXYZ)
      Given a position in a rectangular array of data (the texture), return the corresponding location in physical units.

    • Constructor Detail

      • GenericProjection

        public GenericProjection​(double[][] coordsX,
                         double[][] coordsY)

    • Method Detail

      • getVertexXY

        public void getVertexXY​(double dataFractionX,
                        double dataFractionY,
                        float[] resultXY)
        Description copied from interface: Projection
        Given a position in a rectangular array of data (the texture), return the corresponding location in physical units. The position is given as relative coordinates, with 0.0 indicating the 0th data index and 1.0 indicating the last data index.

        This method computes the physical coordinate of the data at (textureFractionX, textureFractionY), and stores them in the resultXY output parameter.

        Specified by:
        getVertexXY in interface Projection
        Parameters:
        dataFractionX - a relative x index (from 0.0 to 1.0) into the data array
        dataFractionY - a relative y index (from 0.0 to 1.0) into the data array
        resultXY - output parameter to be populated with physical coords of the data

      • getVertexXYZ

        public void getVertexXYZ​(double textureFractionX,
                         double textureFractionY,
                         float[] resultXYZ)
        Description copied from interface: Projection
        Given a position in a rectangular array of data (the texture), return the corresponding location in physical units. The position is given as relative coordinates, with 0.0 indicating the 0th data index and 1.0 indicating the last data index.

        This method computes the physical coordinate of the data at (textureFractionX, textureFractionY), and stores them in the resultXYZ output parameter.

        Assigning z coordinates to vertices can be useful even for 2D graphics. For example, it can be used together with z-clipping to avoid rendering some facets.

        Specified by:
        getVertexXYZ in interface Projection
        Parameters:
        textureFractionX - a relative x index (from 0.0 to 1.0) into the data array
        textureFractionY - a relative y index (from 0.0 to 1.0) into the data array
        resultXYZ - output parameter to be populated with physical coords of the data

      • getSizeX

        public int getSizeX​(int textureSizeX)
        Description copied from interface: Projection
        Returns the number of quads in the x direction that the array of data (the texture) should be broken into. If the projection is linear in the x direction (for example, if the data/texture is simply being displayed on a rectangle) then only one quad is needed.

        For more complicated projections, the value returned essentially defines the granularity or resolution of the projection (since the projection will ultimately be approximated when displayed by drawing a set of small quads).

        Specified by:
        getSizeX in interface Projection
        Parameters:
        textureSizeX - the length of the data array (the texture) in the x direction
        Returns:
        the number of quads in the x direction to draw

      • getSizeY

        public int getSizeY​(int textureSizeY)
        Specified by:
        getSizeY in interface Projection
        Parameters:
        textureSizeY - the length of the data array (the texture) in the y direction
        Returns:
        the number of quads in the y direction to draw
        See Also:
        Projection.getSizeX( int )