Logo
Distributed Genetic Programming Framework
print print

File org.jfree.data.contour.NonGridContourDataset.java

Here you can find all the information about the file org.jfree.data.contour.NonGridContourDataset.java. You may explore it here or download it onto your local disk.
/* ===========================================================
 * JFreeChart : a free chart library for the Java(tm) platform
 * ===========================================================
 *
 * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
 *
 * Project Info:  http://www.jfree.org/jfreechart/index.html
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library 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 Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
 * USA.  
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
 * in the United States and other countries.]
 *
 * --------------------------
 * NonGridContourDataset.java
 * --------------------------
 * (C) Copyright 2002-2005, by David M. O'Donnell.
 *
 * Original Author:  David M. O'Donnell;
 * Contributor(s):   David Gilbert (for Object Refinery Limited);
 *
 * $Id: NonGridContourDataset.java,v 1.3.2.1 2005/10/25 21:30:20 mungady Exp $
 *
 * Changes (from 24-Jul-2003)
 * --------------------------
 * 24-Jul-2003 : Added standard header (DG);
 *
 */


package org.jfree.data.contour;

import org.jfree.data.Range;

/**
 * A convenience class that extends the {@link DefaultContourDataset} to 
 * accommodate non-grid data.
 */

public class NonGridContourDataset extends DefaultContourDataset {

    /** Default number of x values. */
    static final int DEFAULT_NUM_X = 50;
    
    /** Default number of y values. */
    static final int DEFAULT_NUM_Y = 50;
    
    /** Default power. */
    static final int DEFAULT_POWER = 4;

    /**
     * Default constructor.
     */

    public NonGridContourDataset() {
        super();
    }

    /**
     * Constructor for NonGridContourDataset.  Uses default values for grid 
     * dimensions and weighting.
     * 
     * @param seriesName  the series name.
     * @param xData  the x values.
     * @param yData  the y values.
     * @param zData  the z values.
     */

    public NonGridContourDataset(String seriesName,
                                 Object[] xData, Object[] yData, 
                                 Object[] zData) {
        super(seriesName, xData, yData, zData);
        buildGrid(DEFAULT_NUM_X, DEFAULT_NUM_Y, DEFAULT_POWER);
    }

    /**
     * Constructor for NonGridContourDataset.
     * 
     * @param seriesName  the series name.
     * @param xData  the x values.
     * @param yData  the y values.
     * @param zData  the z values.
     * @param numX  number grid cells in along the x-axis
     * @param numY  number grid cells in along the y-axis
     * @param power  exponent for inverse distance weighting
     */

    public NonGridContourDataset(String seriesName, 
                                 Object[] xData, Object[] yData, 
                                 Object[] zData,
                                 int numX, int numY, int power) {
        super(seriesName, xData, yData, zData);
        buildGrid(numX, numY, power);
    }

    /**
     * Builds a regular grid.  Maps the non-grid data into the regular grid 
     * using an inverse distance between grid and non-grid points.  Weighting 
     * of distance can be controlled by setting through the power parameter 
     * that controls the exponent used on the distance weighting 
     * (e.g., distance^power).
     * 
     * @param numX  number grid points in along the x-axis
     * @param numY  number grid points in along the y-axis
     * @param power  exponent for inverse distance weighting
     */

    protected void buildGrid(int numX, int numY, int power) {

        int numValues = numX * numY;
        double[] xGrid = new double[numValues];
        double[] yGrid = new double [numValues];
        double[] zGrid = new double [numValues];

        // Find min, max for the x and y axes
        double xMin = 1.e20;
        for (int k = 0; k < this.xValues.length; k++) {
            xMin = Math.min(xMin, this.xValues[k].doubleValue());
        }

        double xMax = -1.e20;
        for (int k = 0; k < this.xValues.length; k++) {
            xMax = Math.max(xMax, this.xValues[k].doubleValue());
        }

        double yMin = 1.e20;
        for (int k = 0; k < this.yValues.length; k++) {
            yMin = Math.min(yMin, this.yValues[k].doubleValue());
        }

        double yMax = -1.e20;
        for (int k = 0; k < this.yValues.length; k++) {
            yMax = Math.max(yMax, this.yValues[k].doubleValue());
        }

        Range xRange = new Range(xMin, xMax);
        Range yRange = new Range(yMin, yMax);

        xRange.getLength();
        yRange.getLength();

        // Determine the cell size
        double dxGrid = xRange.getLength() / (numX - 1);
        double dyGrid = yRange.getLength() / (numY - 1);

        // Generate the grid
        double x = 0.0;
        for (int i = 0; i < numX; i++) {
            if (i == 0) {
                x = xMin;
            }
            else {
                x += dxGrid;
            }
            double y = 0.0;
            for (int j = 0; j < numY; j++) {
                int k = numY * i + j;
                xGrid[k] = x;
                if (j == 0) {
                    y = yMin;
                }
                else {
                    y += dyGrid;
                }
                yGrid[k] = y;
            }
        }

        // Map the nongrid data into the new regular grid
        for (int kGrid = 0; kGrid < xGrid.length; kGrid++) {
            double dTotal = 0.0;
            zGrid[kGrid] = 0.0;
            for (int k = 0; k < this.xValues.length; k++) {
                double xPt = this.xValues[k].doubleValue();
                double yPt = this.yValues[k].doubleValue();
                double d = distance(xPt, yPt, xGrid[kGrid], yGrid[kGrid]);
                if (power != 1) {
                    d = Math.pow(d, power);
                }
                d = Math.sqrt(d);
                if (d > 0.0) {
                    d = 1.0 / d;
                }
                else { // if d is real small set the inverse to a large number 
                       // to avoid INF
                    d = 1.e20;
                }
                if (this.zValues[k] != null) {
                    // scale by the inverse of distance^power
                    zGrid[kGrid] += this.zValues[k].doubleValue() * d; 
                }
                dTotal += d;
            }
            zGrid[kGrid] = zGrid[kGrid] / dTotal;  //remove distance of the sum
        }

        //initalize xValues, yValues, and zValues arrays.
        initialize(
            formObjectArray(xGrid), formObjectArray(yGrid), 
            formObjectArray(zGrid)
        );

    }

    /**
     * Calculates the distance between two points.
     * 
     * @param xDataPt  the x coordinate.
     * @param yDataPt  the y coordinate.
     * @param xGrdPt  the x grid coordinate.
     * @param yGrdPt  the y grid coordinate.
     * 
     * @return The distance between two points.
     */

    protected double distance(double xDataPt, 
                              double yDataPt, 
                              double xGrdPt, 
                              double yGrdPt) {
        double dx = xDataPt - xGrdPt;
        double dy = yDataPt - yGrdPt;
        return Math.sqrt(dx * dx + dy * dy);
    }

}

File Information:

file name:NonGridContourDataset.java
package:org.jfree.data.contour
qualified name:org.jfree.data.contour.NonGridContourDataset.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/jfree/data/contour/NonGridContourDataset.java
size:7.890 KB (8080 B)
uploaded: 2015-07-22 04:11:06 GMT+0000
last update: 2006-08-25 12:16:44 GMT+0000
last access: 2017-11-17 21:13:38 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2017-11-17 21:13:38 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo