//--------------------------------------------------------------------------
// $Id: x21.java 12329 2013-05-02 22:44:50Z airwin $
//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
// Copyright (C) 2006  Andrew Ross
// Copyright (C) 2004  Alan W. Irwin
//
// This file is part of PLplot.
//
// PLplot is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; version 2 of the License.
//
// PLplot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with PLplot; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
// Implementation of PLplot example 21 in Java.
//--------------------------------------------------------------------------

package plplot.examples;

import plplot.core.*;
import static plplot.core.plplotjavacConstants.*;

import java.lang.Math;

class x21 {
    // Class data
    PLStream pls = new PLStream();

    double   xm, xM, ym, yM;

    // Options data structure definition.
    static int    pts       = 500;
    static int    xp        = 25;
    static int    yp        = 20;
    static int    nl        = 16;
    static int    knn_order = 20;
    static double threshold = 1.001;
    static double wmin      = -1e3;
    static int    randn     = 0;
    static int    rosen     = 0;

    //  static PLOptionTable options[];


    // PLOptionTable options[] = {
    //   {
    //     "npts",
    //     NULL,
    //     NULL,
    //     &pts,
    //     PL_OPT_INT,
    //     "-npts points",
    //     "Specify number of random points to generate [500]" },
    //   {
    //     "randn",
    //     NULL,
    //     NULL,
    //     &randn,
    //     PL_OPT_BOOL,
    //     "-randn",
    //     "Normal instead of uniform sampling -- the effective
    //     number of points will be smaller than the specified." },
    //   {
    //     "rosen",
    //     NULL,
    //     NULL,
    //     &rosen,
    //     PL_OPT_BOOL,
    //     "-rosen",
    //     "Generate points from the Rosenbrock function."},
    //   {
    //     "nx",
    //     NULL,
    //     NULL,
    //     &xp,
    //     PL_OPT_INT,
    //     "-nx points",
    //     "Specify grid x dimension [25]" },
    //   {
    //     "ny",
    //     NULL,
    //     NULL,
    //     &yp,
    //     PL_OPT_INT,
    //     "-ny points",
    //     "Specify grid y dimension [20]" },
    //   {
    //     "nlevel",
    //     NULL,
    //     NULL,
    //     &nl,
    //     PL_OPT_INT,
    //     "-nlevel ",
    //     "Specify number of contour levels [16]" },
    //   {
    //     "knn_order",
    //     NULL,
    //     NULL,
    //     &knn_order,
    //     PL_OPT_INT,
    //     "-knn_order order",
    //     "Specify the number of neighbors [20]" },
    //   {
    //     "threshold",
    //     NULL,
    //     NULL,
    //     &threshold,
    //     PL_OPT_FLOAT,
    //     "-threshold float",
    //     "Specify what a thin triangle is [1. < [1.001] < 2.]" },

    //   {
    //     NULL,                       /* option */
    //     NULL,                       /* handler */
    //     NULL,                       /* client data */
    //     NULL,                       /* address of variable to set */
    //     0,                          /* mode flag */
    //     NULL,                       /* short syntax */
    //     NULL }                      /* long syntax */
    // };

    x21( String[] args )
    {
        double x[], y[], z[], clev[];
        double xg[], yg[], zg[][];
        double xg0[][], yg0[][];
        double xx[], yy[];
        double zmin, zmax, lzm[], lzM[];
        int    i, j, k;
        int    alg;
        String title[] = { "Cubic Spline Approximation",
                           "Delaunay Linear Interpolation",
                           "Natural Neighbors Interpolation",
                           "KNN Inv. Distance Weighted",
                           "3NN Linear Interpolation",
                           "4NN Around Inv. Dist. Weighted" };

        double opt[] = { 0., 0., 0., 0., 0., 0. };

        xm = ym = -0.2;
        xM = yM = 0.6;

        // plplot initialization

        // Parse and process command line arguments.
        // pls.MergeOpts(options, "x22c options", NULL);
        pls.parseopts( args, PL_PARSE_FULL | PL_PARSE_NOPROGRAM );

        opt[2] = wmin;
        opt[3] = knn_order;
        opt[4] = threshold;

        // Initialize PLplot.
        pls.init();

        cmap1_init();

        pls.seed( 5489 );

        x  = new double[pts];
        y  = new double[pts];
        z  = new double[pts];
        xx = new double[1];
        yy = new double[1];

        create_data( x, y, z ); // the sampled data
        zmin = z[0];
        zmax = z[0];
        for ( i = 1; i < pts; i++ )
        {
            if ( z[i] > zmax )
                zmax = z[i];
            if ( z[i] < zmin )
                zmin = z[i];
        }

        xg = new double[xp];
        yg = new double[yp];

        create_grid( xg, yg );   // grid the data at
        zg = new double[xp][yp]; // the output grided data

        xg0 = new double[xp][yp];
        yg0 = new double[xp][yp];

        for ( i = 0; i < xp; i++ )
        {
            for ( j = 0; j < yp; j++ )
            {
                xg0[i][j] = xg[i];
                yg0[i][j] = yg[j];
            }
        }

        clev = new double[nl];

        pls.col0( 1 );
        pls.env( xm, xM, ym, yM, 2, 0 );
        pls.col0( 15 );
        pls.lab( "X", "Y", "The original data sampling" );
        for ( i = 0; i < pts; i++ )
        {
            pls.col1( ( z[i] - zmin ) / ( zmax - zmin ) );
            // The following plstring call should be the the equivalent of
            // plpoin( 1, &x[i], &y[i], 5 ); Use plstring because it is
            // not deprecated like plpoin and has much more powerful
            // capabilities.  N.B. symbol 141 works for Hershey devices
            // (e.g., -dev xwin) only if plfontld( 0 ) has been called
            // while symbol 727 works only if plfontld( 1 ) has been
            // called.  The latter is the default which is why we use 727
            // here to represent a centred X (multiplication) symbol.
            // This dependence on plfontld is one of the limitations of
            // the Hershey escapes for PLplot, but the upside is you get
            // reasonable results for both Hershey and Unicode devices.
            xx[0] = x[i];
            yy[0] = y[i];
            pls.string( xx, yy, "#(727)" );
        }
        pls.adv( 0 );

        pls.ssub( 3, 2 );

        for ( k = 0; k < 2; k++ )
        {
            pls.adv( 0 );
            for ( alg = 1; alg < 7; alg++ )
            {
                pls.griddata( x, y, z, xg, yg, zg, alg, opt[alg - 1] );

                // - CSA can generate NaNs (only interpolates?!).
                // - DTLI and NNI can generate NaNs for points outside the
                //      convex hull of the data points.
                // - NNLI can generate NaNs if a sufficiently thick triangle
                //      is not found
                //
                // PLplot should be NaN/Inf aware, but changing it now is
                // quite a job... so, instead of not plotting the NaN
                // regions, a weighted average over the neighbors is done.
                //

                if ( alg == GRID_CSA || alg == GRID_DTLI ||
                     alg == GRID_NNLI || alg == GRID_NNI )
                {
                    int    ii, jj;
                    double dist, d;

                    for ( i = 0; i < xp; i++ )
                    {
                        for ( j = 0; j < yp; j++ )
                        {
                            if ( Double.isNaN( zg[i][j] ) )   // average (IDW) over the 8 neighbors

                            {
                                zg[i][j] = 0.; dist = 0.;

                                for ( ii = i - 1; ii <= i + 1 && ii < xp; ii++ )
                                {
                                    for ( jj = j - 1; jj <= j + 1 && jj < yp; jj++ )
                                    {
                                        if ( ii >= 0 && jj >= 0 && !Double.isNaN( zg[ii][jj] ) )
                                        {
                                            d         = ( Math.abs( ii - i ) + Math.abs( jj - j ) ) == 1 ? 1. : 1.4142;
                                            zg[i][j] += zg[ii][jj] / ( d * d );
                                            dist     += d;
                                        }
                                    }
                                }
                                if ( dist != 0. )
                                    zg[i][j] /= dist;
                                else
                                    zg[i][j] = zmin;
                            }
                        }
                    }
                }

                lzm = new double[1];
                lzM = new double[1];
                pls.minMax2dGrid( zg, lzM, lzm );
                lzm[0] = Math.min( lzm[0], zmin );
                lzM[0] = Math.max( lzM[0], zmax );
                lzm[0] = lzm[0] - 0.01;
                lzM[0] = lzM[0] + 0.01;

                pls.col0( 1 );
                pls.adv( alg );

                if ( k == 0 )
                {
                    for ( i = 0; i < nl; i++ )
                        clev[i] = lzm[0] + ( lzM[0] - lzm[0] ) / ( nl - 1 ) * i;

                    pls.env0( xm, xM, ym, yM, 2, 0 );
                    pls.col0( 15 );
                    pls.lab( "X", "Y", title[alg - 1] );
                    pls.shades( zg, xm, xM, ym, yM,
                        clev, 1., 0, 1., true, xg0, yg0 );
                    pls.col0( 2 );
                }
                else
                {
                    for ( i = 0; i < nl; i++ )
                        clev[i] = lzm[0] + ( lzM[0] - lzm[0] ) / ( nl - 1 ) * i;

                    pls.vpor( 0.0, 1.0, 0.0, 0.9 );
                    pls.wind( -1.1, 0.75, -0.65, 1.20 );
                    //
                    // For the comparison to be fair, all plots should have the
                    // same z values, but to get the max/min of the data
                    // generated by all algorithms would imply two passes.
                    // Keep it simple.
                    //
                    // plw3d(1., 1., 1., xm, xM, ym, yM, zmin, zmax, 30, -60);
                    //

                    pls.w3d( 1., 1., 1., xm, xM, ym, yM, lzm[0], lzM[0], 30, -40 );
                    pls.box3( "bntu", "X", 0.0, 0,
                        "bntu", "Y", 0.0, 0,
                        "bcdfntu", "Z", 0.5, 0 );
                    pls.col0( 15 );
                    pls.lab( "", "", title[alg - 1] );
                    pls.plot3dc( xg, yg, zg, DRAW_LINEXY |
                        MAG_COLOR | BASE_CONT,
                        clev );
                }
            }
        }

        pls.end();
    }

    void cmap1_init()
    {
        double i[] = new double[2];
        double h[] = new double[2];
        double l[] = new double[2];
        double s[] = new double[2];

        i[0] = 0.0;           // left boundary
        i[1] = 1.0;           // right boundary

        h[0] = 240;           // blue . green . yellow .
        h[1] = 0;             // . red

        l[0] = 0.6;
        l[1] = 0.6;

        s[0] = 0.8;
        s[1] = 0.8;

        pls.scmap1n( 256 );
        pls.scmap1l( false, i, h, l, s );
    }

    void create_grid( double xx[], double yy[] )
    {
        int i;
        int px = xx.length;
        int py = yy.length;

        for ( i = 0; i < px; i++ )
            xx[i] = xm + ( xM - xm ) * i / ( px - 1. );

        for ( i = 0; i < py; i++ )
            yy[i] = ym + ( yM - ym ) * i / ( py - 1. );
    }

    void create_data( double x[], double y[], double z[] )
    {
        int    i;
        double r;
        double xt, yt;
        int    pts = x.length;

        for ( i = 0; i < pts; i++ )
        {
            xt = ( xM - xm ) * pls.randd();
            yt = ( yM - ym ) * pls.randd();
            if ( randn == 0 )
            {
                x[i] = xt + xm;
                y[i] = yt + ym;
            }
            else     // std=1, meaning that many points are outside the plot range
            {
                x[i] = Math.sqrt( -2. * Math.log( xt ) ) * Math.cos( 2. * Math.PI * yt ) + xm;
                y[i] = Math.sqrt( -2. * Math.log( xt ) ) * Math.sin( 2. * Math.PI * yt ) + ym;
            }
            if ( rosen == 0 )
            {
                r    = Math.sqrt( ( x[i] ) * ( x[i] ) + ( y[i] ) * ( y[i] ) );
                z[i] = Math.exp( -r * r ) * Math.cos( 2.0 * Math.PI * r );
            }
            else
            {
                z[i] = Math.log( Math.pow( ( 1. - x[i] ), 2. ) + 100. * Math.pow( ( y[i] - Math.pow( x[i], 2. ) ), 2. ) );
            }
        }
    }

    public static void main( String[] args )
    {
        new x21( args );
    }
}

//--------------------------------------------------------------------------
//                              End of x21.java
//--------------------------------------------------------------------------


