1. /* ===========================================================

  2.  * JFreeChart : a free chart library for the Java(tm) platform

  3.  * ===========================================================

  4.  *

  5.  * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.

  6.  *

  7.  * Project Info:  http://www.jfree.org/jfreechart/index.html

  8.  *

  9.  * This library is free software; you can redistribute it and/or modify it 

  10.  * under the terms of the GNU Lesser General Public License as published by 

  11.  * the Free Software Foundation; either version 2.1 of the License, or 

  12.  * (at your option) any later version.

  13.  *

  14.  * This library is distributed in the hope that it will be useful, but 

  15.  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 

  16.  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 

  17.  * License for more details.

  18.  *

  19.  * You should have received a copy of the GNU Lesser General Public License 

  20.  * along with this library; if not, write to the Free Software Foundation, 

  21.  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

  22.  *

  23.  * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 

  24.  * in the United States and other countries.]

  25.  *

  26.  * --------------------------

  27.  * NonGridContourDataset.java

  28.  * --------------------------

  29.  * (C) Copyright 2002-2005, by David M. O'Donnell.

  30.  *

  31.  * Original Author:  David M. O'Donnell;

  32.  * Contributor(s):   David Gilbert (for Object Refinery Limited);

  33.  *

  34.  * $Id: NonGridContourDataset.java,v 1.3 2005/02/24 10:11:25 mungady Exp $

  35.  *

  36.  * Changes (from 24-Jul-2003)

  37.  * --------------------------

  38.  * 24-Jul-2003 : Added standard header (DG);

  39.  *

  40.  */

  41. 

  42. package org.jfree.data.contour;

  43. 

  44. import org.jfree.data.Range;

  45. 

  46. /**

  47.  * A convenience class that extends the {@link DefaultContourDataset} to 

  48.  * accommodate non-grid data.

  49.  */

  50. public class NonGridContourDataset extends DefaultContourDataset {

  51. 

  52.     /** Default number of x values. */

  53.     static final int DEFAULT_NUM_X = 50;

  54.     

  55.     /** Default number of y values. */

  56.     static final int DEFAULT_NUM_Y = 50;

  57.     

  58.     /** Default power. */

  59.     static final int DEFAULT_POWER = 4;

  60. 

  61.     /**

  62.      * Default constructor.

  63.      */

  64.     public NonGridContourDataset() {

  65.         super();

  66.     }

  67. 

  68.     /**

  69.      * Constructor for NonGridContourDataset.  Uses default values for grid 

  70.      * dimensions and weighting.

  71.      * 

  72.      * @param seriesName  the series name.

  73.      * @param xData  the x values.

  74.      * @param yData  the y values.

  75.      * @param zData  the z values.

  76.      */

  77.     public NonGridContourDataset(String seriesName,

  78.                                  Object[] xData, Object[] yData, 

  79.                                  Object[] zData) {

  80.         super(seriesName, xData, yData, zData);

  81.         buildGrid(DEFAULT_NUM_X, DEFAULT_NUM_Y, DEFAULT_POWER);

  82.     }

  83. 

  84.     /**

  85.      * Constructor for NonGridContourDataset.

  86.      * 

  87.      * @param seriesName  the series name.

  88.      * @param xData  the x values.

  89.      * @param yData  the y values.

  90.      * @param zData  the z values.

  91.      * @param numX  number grid cells in along the x-axis

  92.      * @param numY  number grid cells in along the y-axis

  93.      * @param power  exponent for inverse distance weighting

  94.      */

  95.     public NonGridContourDataset(String seriesName, 

  96.                                  Object[] xData, Object[] yData, 

  97.                                  Object[] zData,

  98.                                  int numX, int numY, int power) {

  99.         super(seriesName, xData, yData, zData);

  100.         buildGrid(numX, numY, power);

  101.     }

  102. 

  103.     /**

  104.      * Builds a regular grid.  Maps the non-grid data into the regular grid 

  105.      * using an inverse distance between grid and non-grid points.  Weighting 

  106.      * of distance can be controlled by setting through the power parameter 

  107.      * that controls the exponent used on the distance weighting 

  108.      * (e.g., distance^power).

  109.      * 

  110.      * @param numX  number grid points in along the x-axis

  111.      * @param numY  number grid points in along the y-axis

  112.      * @param power  exponent for inverse distance weighting

  113.      */

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

  115. 

  116.         int numValues = numX * numY;

  117.         double[] xGrid = new double[numValues];

  118.         double[] yGrid = new double [numValues];

  119.         double[] zGrid = new double [numValues];

  120. 

  121.         // Find min, max for the x and y axes

  122.         double xMin = 1.e20;

  123.         for (int k = 0; k < this.xValues.length; k++) {

  124.             xMin = Math.min(xMin, this.xValues[k].doubleValue());

  125.         }

  126. 

  127.         double xMax = -1.e20;

  128.         for (int k = 0; k < this.xValues.length; k++) {

  129.             xMax = Math.max(xMax, this.xValues[k].doubleValue());

  130.         }

  131. 

  132.         double yMin = 1.e20;

  133.         for (int k = 0; k < this.yValues.length; k++) {

  134.             yMin = Math.min(yMin, this.yValues[k].doubleValue());

  135.         }

  136. 

  137.         double yMax = -1.e20;

  138.         for (int k = 0; k < this.yValues.length; k++) {

  139.             yMax = Math.max(yMax, this.yValues[k].doubleValue());

  140.         }

  141. 

  142.         Range xRange = new Range(xMin, xMax);

  143.         Range yRange = new Range(yMin, yMax);

  144. 

  145.         xRange.getLength();

  146.         yRange.getLength();

  147. 

  148.         // Determine the cell size

  149.         double dxGrid = xRange.getLength() / (numX - 1);

  150.         double dyGrid = yRange.getLength() / (numY - 1);

  151. 

  152.         // Generate the grid

  153.         double x = 0.0;

  154.         for (int i = 0; i < numX; i++) {

  155.             if (i == 0) {

  156.                 x = xMin;

  157.             }

  158.             else {

  159.                 x += dxGrid;

  160.             }

  161.             double y = 0.0;

  162.             for (int j = 0; j < numY; j++) {

  163.                 int k = numY * i + j;

  164.                 xGrid[k] = x;

  165.                 if (j == 0) {

  166.                     y = yMin;

  167.                 }

  168.                 else {

  169.                     y += dyGrid;

  170.                 }

  171.                 yGrid[k] = y;

  172.             }

  173.         }

  174. 

  175.         // Map the nongrid data into the new regular grid

  176.         for (int kGrid = 0; kGrid < xGrid.length; kGrid++) {

  177.             double dTotal = 0.0;

  178.             zGrid[kGrid] = 0.0;

  179.             for (int k = 0; k < this.xValues.length; k++) {

  180.                 double xPt = this.xValues[k].doubleValue();

  181.                 double yPt = this.yValues[k].doubleValue();

  182.                 double d = distance(xPt, yPt, xGrid[kGrid], yGrid[kGrid]);

  183.                 if (power != 1) {

  184.                     d = Math.pow(d, power);

  185.                 }

  186.                 d = Math.sqrt(d);

  187.                 if (d > 0.0) {

  188.                     d = 1.0 / d;

  189.                 }

  190.                 else { // if d is real small set the inverse to a large number 

  191.                        // to avoid INF

  192.                     d = 1.e20;

  193.                 }

  194.                 if (this.zValues[k] != null) {

  195.                     // scale by the inverse of distance^power

  196.                     zGrid[kGrid] += this.zValues[k].doubleValue() * d; 

  197.                 }

  198.                 dTotal += d;

  199.             }

  200.             zGrid[kGrid] = zGrid[kGrid] / dTotal;  //remove distance of the sum

  201.         }

  202. 

  203.         //initalize xValues, yValues, and zValues arrays.

  204.         initialize(

  205.             formObjectArray(xGrid), formObjectArray(yGrid), 

  206.             formObjectArray(zGrid)

  207.         );

  208. 

  209.     }

  210. 

  211.     /**

  212.      * Calculates the distance between two points.

  213.      * 

  214.      * @param xDataPt  the x coordinate.

  215.      * @param yDataPt  the y coordinate.

  216.      * @param xGrdPt  the x grid coordinate.

  217.      * @param yGrdPt  the y grid coordinate.

  218.      * 

  219.      * @return The distance between two points.

  220.      */

  221.     protected double distance(double xDataPt, 

  222.                               double yDataPt, 

  223.                               double xGrdPt, 

  224.                               double yGrdPt) {

  225.         double dx = xDataPt - xGrdPt;

  226.         double dy = yDataPt - yGrdPt;

  227.         return Math.sqrt(dx * dx + dy * dy);

  228.     }

  229. 

  230. }