/**
 * This software was developed and / or modified by Raytheon Company,
 * pursuant to Contract DG133W-05-CQ-1067 with the US Government.
 * 
 * U.S. EXPORT CONTROLLED TECHNICAL DATA
 * This software product contains export-restricted data whose
 * export/transfer/disclosure is restricted by U.S. law. Dissemination
 * to non-U.S. persons whether in the United States or abroad requires
 * an export license or other authorization.
 * 
 * Contractor Name:        Raytheon Company
 * Contractor Address:     6825 Pine Street, Suite 340
 *                         Mail Stop B8
 *                         Omaha, NE 68106
 *                         402.291.0100
 * 
 * See the AWIPS II Master Rights File ("Master Rights File.pdf") for
 * further licensing information.
 **/
/**
 * 
 */
package com.raytheon.viz.gfe.contours;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

import com.raytheon.uf.common.dataplugin.gfe.grid.Grid2DFloat;
import com.raytheon.viz.gfe.contours.util.CLine;
import com.raytheon.viz.gfe.contours.util.ContourValueDistance;
import com.raytheon.viz.gfe.contours.util.SearchDir;
import com.vividsolutions.jts.geom.Coordinate;

/**
 * @author wdougherty
 * 
 */
public class TestContourAnalyzer {

    private static final int SUBGRID_FACTOR = 4;

    private static final int XDIM = 10;

    private static final int YDIM = 10;

    private static final int XDIMBIG = 143;

    private static final int YDIMBIG = 143;

    private static final float[] ORIGINAL_VALUES;
    static {
        float[] tmp = new float[XDIM * YDIM];
        for (int i = 0; i < XDIM * YDIM; i++) {
            tmp[i] = (i - XDIM * YDIM);
        }
        ORIGINAL_VALUES = tmp;
    }

    public ContourAnalyzer analyzer;

    private Grid2DFloat originalGrid;

    private List<CLine> contours;

    private float xOrigin;

    private float yOrigin;

    private float xGridRatio;

    private float yGridRatio;

    private int xMin;

    private int xMax;

    private int yMin;

    private int yMax;

    private float valMin;

    private float valMax;

    private boolean clampOn;

    // private GeometryFactory factory;

    // private CoordinateSequenceFactory seqFactory;

    // private CoordinateSequence cseq;

    private CLine contour;

    private float contourLevel;

    private Grid2DFloat result;

    // testDoAnalysis(), testGridValueFromGradient(), and
    // testComputeShadowAreas() work on the output of successive stages of
    // analysis on the same grid.
    // This is output from the legacy system for that grid.
    private static final float[] REGRESSIONDATA;
    static {
        REGRESSIONDATA = new float[] { 7.84327f, 5.96378f, 6.0503f, 1.50418f,
                4.36618f, 3.66293f, 6f, 6f, 4.04976f, 3.88061f, 8.01783f,
                7.77779f, 5.46911f, 5.57095f, 3.00279f, 5.31989f, 5.42566f,
                6.22717f, 4.58707f, 5.87048f, 8.26714f, 8.06572f, 7.78835f,
                5.39567f, 5.55349f, 4.50139f, 5.65495f, 6.38618f, 6.5898f,
                6.03285f, 2.02754f, 8.46209f, 8.28246f, 8.01465f, 4.67585f,
                5.33792f, 6f, 7.02801f, 7.32415f, 7.98623f, 8.8943f, 7.99071f,
                9.78866f, 8.8779f, 8.81802f, 8.42469f, 8.53871f, 8.69406f,
                8.81388f, 8.87169f, 8.98692f, 10.1995f, 8.47962f, 9.77953f,
                10.1211f, 10.1349f, 11.0184f, 10.6321f, 10.1308f, 9.79553f,
                15.0084f, 9.83671f, 10.0956f, 10.4576f, 13.0028f, 12.5014f,
                12f, 11.5288f, 10.9972f, 10.4958f, 9.92034f, 10.1534f,
                10.4598f, 12.5776f, 12.4059f, 13.3379f, 12.2844f, 11.7405f,
                11.6913f, 12.1395f, 10.1143f, 10.3609f, 12.4444f, 12.4115f,
                14.6758f, 12.6393f, 12.4409f, 12f, 13.3856f, 12.3722f,
                10.2388f, 11.9461f, 11.9149f, 16.0138f, 13.5024f, 14.1094f,
                12f, 12f, 13.8694f, 14.0784f };
    }

    /**
     * @throws java.lang.Exception
     */
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        // Configure log4j
        // BasicConfigurator.configure();
    }

    /**
     * @throws java.lang.Exception
     */
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
    }

    /**
     * This initializes fields to default values for the ContourAnalyzer ctor,
     * so our test cases can just override the defaults we need.
     * 
     * @throws java.lang.Exception
     */
    @Before
    public void setUp() throws Exception {
        // Set the most common values to pass to the ContourAnalyzer ctor.
        originalGrid = new Grid2DFloat(XDIM, YDIM, ORIGINAL_VALUES);
        contours = new ArrayList<CLine>(); // most tests will add points
        xOrigin = 0;
        yOrigin = 0;
        xGridRatio = 1.0f;
        yGridRatio = 1.0f;
        xMin = 0;
        xMax = XDIM;
        yMin = 0;
        yMax = YDIM;
        clampOn = false;
        valMax = 1e37f;
        valMin = -valMax;
        // factory = new GeometryFactory();
        // seqFactory = factory.getCoordinateSequenceFactory();
        contourLevel = 100.0f;
    }

    /**
     * @throws java.lang.Exception
     */
    @After
    public void tearDown() throws Exception {
    }

    /**
     * Helper method for comparing the expected output grid to the actual output
     * grid. We'll do this a lot. The label gives us something to make it easier
     * to determine which test failed.
     * 
     * @param expected
     *            The Grid2DFloat we expected to get out of the analyzer.
     * @param result
     *            The grid we actually got from the analyzer.
     * @param label
     *            A string to help us distinguish between test cases
     */
    public void checkResult(Grid2DFloat expected, Grid2DFloat result,
            String label) {
        assertEquals(label + ":getXdim()", expected.getXdim(), result.getXdim());
        assertEquals(label + ":getYdim()", expected.getYdim(), result.getYdim());
        assertArrayEquals(label + ":values", expected.getNumPy(),
                result.getNumPy());
    }

    /**
     * @param label
     * @param expected
     */
    private void invokeAnalyzer(String label, Grid2DFloat expected) {
        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);
        analyzer.recomputeGrid();
        result = analyzer.getFinalResultData();
        checkResult(expected, result, label);
    }

    @Test
    public void testSimplestContour() throws Exception {
        Coordinate[] outerRing = new Coordinate[5];
        outerRing[0] = new Coordinate(-1.0, -1.0);
        outerRing[1] = new Coordinate((XDIM + 1), -1.0);
        outerRing[2] = new Coordinate((XDIM + 1), (YDIM + 1));
        outerRing[3] = new Coordinate(-1.0, (YDIM + 1));
        outerRing[4] = new Coordinate(-1.0, -1.0);
        // cseq = seqFactory.create(outerRing);
        contour = new CLine(outerRing, contourLevel, true);
        contours.add(contour);
        Grid2DFloat expected = new Grid2DFloat(XDIM, YDIM, contourLevel);

        invokeAnalyzer("testSimplestContour", expected);
    }

    @Test
    public void testDiagonalBars() throws Exception {
        Coordinate[] firstBar = new Coordinate[2];
        firstBar[0] = new Coordinate(0.0, 2.0);
        firstBar[1] = new Coordinate(2.0, 0.0);
        // cseq = seqFactory.create(firstBar);
        contourLevel = 1.0f;
        contour = new CLine(firstBar, contourLevel, true);
        contours.add(contour);

        Coordinate[] secondBar = new Coordinate[2];
        secondBar[0] = new Coordinate(0.0, 5.0);
        secondBar[1] = new Coordinate(5.0, 0.0);
        // cseq = seqFactory.create(secondBar);
        contourLevel = 4.0f;
        contour = new CLine(secondBar, contourLevel, true);
        contours.add(contour);

        Coordinate[] thirdBar = new Coordinate[2];
        thirdBar[0] = new Coordinate(0.0, 8.0);
        thirdBar[1] = new Coordinate(8.0, 0.0);
        // cseq = seqFactory.create(thirdBar);
        contourLevel = 9.0f;
        contour = new CLine(thirdBar, contourLevel, true);
        contours.add(contour);
        float[] EA = new float[] { -1f, 8.39801e-18f, 1f, 3.33244f, 4f, 4f,
                7.77489f, 9f, 9f, 10.6667f, 8.39801e-18f, 1f, 2.9833f, 4f, 4f,
                7.18292f, 9f, 9f, 10.6667f, 12.3333f, 1f, 2.9833f, 4f, 4f,
                7.03335f, 9f, 9f, 10.6667f, 11.0984f, 14f, 3.33244f, 4f, 4f,
                7.00384f, 9f, 9f, 10.3579f, 12.3333f, 14f, 13.1967f, 4f, 4f,
                7.03335f, 9f, 9f, 10.6667f, 11.7159f, 14f, 15.6667f, 17.3333f,
                4f, 7.18292f, 9f, 9f, 10.6667f, 12.3333f, 13.0738f, 15.6667f,
                17.3333f, 19f, 7.77488f, 9f, 9f, 10.3579f, 11.7159f, 13.0738f,
                13.1967f, 15.1502f, 16.3802f, 17.6103f, 9f, 9f, 10.6667f,
                12.3333f, 14f, 15.6667f, 15.1502f, 19f, 20.6667f, 22.3333f, 9f,
                10.6667f, 11.0984f, 14f, 15.6667f, 17.3333f, 16.3802f,
                20.6667f, 22.3333f, 24f, 10.6667f, 12.3333f, 14f, 13.1967f,
                17.3333f, 19f, 17.6103f, 22.3333f, 24f, 25.6667f };

        Grid2DFloat expected = new Grid2DFloat(XDIM, YDIM, EA);
        invokeAnalyzer("Diagonal Bars", expected);
    }

    @Ignore
    @Test
    public void testConcentricCircles() throws Exception {
        final int CIRC_PTS = 12;
        Coordinate[] bigCircle = new Coordinate[CIRC_PTS + 1];
        Coordinate[] midCircle = new Coordinate[CIRC_PTS + 1];
        Coordinate[] littleCircle = new Coordinate[CIRC_PTS + 1];
        double angle;
        double xmult;
        double ymult;
        for (int i = 0; i < CIRC_PTS; i++) {
            angle = i * 2 * Math.PI / CIRC_PTS;
            xmult = Math.cos(angle);
            ymult = Math.sin(angle);
            bigCircle[i] = new Coordinate();
            bigCircle[i].x = XDIM / 2 + ((XDIM - 1) / 2) * xmult;
            bigCircle[i].y = YDIM / 2 + ((YDIM - 1) / 2) * ymult;
            midCircle[i] = new Coordinate();
            midCircle[i].x = XDIM / 2 + (XDIM / 3) * xmult;
            midCircle[i].y = YDIM / 2 + (YDIM / 3) * ymult;

            littleCircle[i] = new Coordinate();
            littleCircle[i].x = XDIM / 2 + (XDIM / 5) * xmult;
            littleCircle[i].y = YDIM / 2 + (YDIM / 5) * ymult;
        }
        bigCircle[CIRC_PTS] = new Coordinate(bigCircle[0]);
        midCircle[CIRC_PTS] = new Coordinate(midCircle[0]);
        littleCircle[CIRC_PTS] = new Coordinate(littleCircle[0]);

        // cseq = this.seqFactory.create(bigCircle);
        contourLevel = 4.0f;
        contour = new CLine(bigCircle, contourLevel, true);
        contours.add(contour);

        // cseq = this.seqFactory.create(midCircle);
        contourLevel = 4.0f; // on purpose
        contour = new CLine(midCircle, contourLevel, true);
        contours.add(contour);

        // cseq = this.seqFactory.create(littleCircle);
        contourLevel = 2.0f;
        contour = new CLine(littleCircle, contourLevel, true);
        contours.add(contour);

        Grid2DFloat expected = new Grid2DFloat(XDIM, YDIM, 1.0f);
        invokeAnalyzer("Concentric circles", expected);
    }

    @Test
    public void testFindNearestNorth() throws Exception {
        testFindNearestMajor(SearchDir.N);
    }

    @Test
    public void testFindNearestSouth() throws Exception {
        testFindNearestMajor(SearchDir.S);
    }

    @Test
    public void testFindNearestEast() throws Exception {
        testFindNearestMajor(SearchDir.E);
    }

    @Test
    public void testFindNearestWest() throws Exception {
        testFindNearestMajor(SearchDir.W);
    }

    private void testFindNearestMajor(SearchDir dir) throws Exception {
        Coordinate[] line = new Coordinate[2];

        double lineOriginX = Double.NaN;
        double lineOriginY = Double.NaN;
        double lineLimitX = Double.NaN;
        double lineLimitY = Double.NaN;

        switch (dir) {
        case N:
        case S:
            lineOriginX = 0;
            lineOriginY = YDIM / 2;
            lineLimitX = XDIM - 1;
            lineLimitY = YDIM / 2;
            break;
        case E:
        case W:
            lineOriginX = XDIM / 2;
            lineOriginY = 0;
            lineLimitX = XDIM / 2;
            lineLimitY = YDIM - 1;
            break;
        default:
            fail("testFindNearestMajor: cannot work with direction " + dir);
        }

        line[0] = new Coordinate(lineOriginX, lineOriginY);
        line[1] = new Coordinate(lineLimitX, lineLimitY);
        // cseq = this.seqFactory.create(line);
        contourLevel = 10.0f;
        contour = new CLine(line, contourLevel, true);
        contours.add(contour);

        // ContourAnalyzer ctor won't set up for findNearestContour()
        // properly if we don't have two contours. However, the
        // contours don't have to be confined to the grid, so create
        // a second contour that should never be seen.
        Coordinate[] brLine = new Coordinate[2];
        brLine[0] = new Coordinate(XDIM + 1, 0);
        brLine[1] = new Coordinate(XDIM + 2, 1);
        // cseq = this.seqFactory.create(brLine);
        contourLevel = 999;
        contour = new CLine(brLine, contourLevel, true);
        contours.add(contour);

        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);
        ContourValueDistance cvd = new ContourValueDistance();

        int i = Integer.MIN_VALUE;
        int j = Integer.MIN_VALUE;

        switch (dir) {
        case N:
            i = 1;
            j = YDIM / 2 - 1;
            break;
        case S:
            i = 1;
            j = YDIM / 2 + 1;
            break;
        case E:
            i = XDIM / 2 - 1;
            j = 1;
            break;
        case W:
            i = XDIM / 2 + 1;
            j = 1;
            break;
        }

        boolean found;
        found = analyzer.findNearestContour(i, j, dir, cvd);
        String testID = "testFindNearest(" + dir + "):" + i + "," + j;
        assertEquals(testID, true, found);
        assertEquals(testID, 10.0, cvd.value);
        assertEquals(testID, SUBGRID_FACTOR, cvd.distance);

        switch (dir) {
        case N:
            j = YDIM / 2 + 1;
            break;
        case S:
            j = YDIM / 2 - 1;
            break;
        case E:
            i = XDIM / 2 + 1;
            j = 2; // otherwise, we see brLine: it was snapped to the grid edge.
            break;
        case W:
            i = XDIM / 2 - 1;
            break;
        }

        found = analyzer.findNearestContour(i, j, dir, cvd);
        testID = "testFindNearest(" + dir + "):" + i + "," + j;
        assertEquals(testID, false, found);

        // Try with a contour on the edge of the grid
        contours.clear();
        // put brLine back in
        contours.add(contour);

        switch (dir) {
        case N:
            lineOriginX = 0;
            lineOriginY = YDIM - 1;
            lineLimitX = XDIM - 1;
            lineLimitY = YDIM - 1;
            break;
        case S:
            lineOriginX = 0;
            lineOriginY = 0;
            lineLimitX = XDIM - 1;
            lineLimitY = 0;
            break;
        case E:
            lineOriginX = XDIM - 1;
            lineOriginY = 0;
            lineLimitX = XDIM - 1;
            lineLimitY = YDIM - 1;
            break;
        case W:
            lineOriginX = 0;
            lineOriginY = 0;
            lineLimitX = 0;
            lineLimitY = YDIM - 1;
            break;
        }

        line[0] = new Coordinate(lineOriginX, lineOriginY);
        line[1] = new Coordinate(lineLimitX, lineLimitY);
        // cseq = seqFactory.create(line);
        contourLevel = 10.0f;
        contour = new CLine(line, contourLevel, true);
        contours.add(contour);

        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);

        switch (dir) {
        case N:
            i = 1;
            j = YDIM - 2;
            break;
        case S:
            i = 1;
            j = 1;
            break;
        case E:
            i = XDIM - 2;
            j = 1;
            break;
        case W:
            i = 1;
            j = 1;
            break;
        }

        found = analyzer.findNearestContour(i, j, dir, cvd);
        testID = "testFindNearest(" + dir + "):" + i + "," + j;
        assertEquals(testID, true, found);
        assertEquals(testID, 10.0, cvd.value);
        assertEquals(testID, SUBGRID_FACTOR, cvd.distance);

        // Shouldn't find it to dir if we're on the contour
        switch (dir) {
        case N:
            j = YDIM - 1;
            break;
        case S:
            j = 0;
            break;
        case E:
            i = XDIM - 1;
            break;
        case W:
            i = 0;
            break;
        }
        found = analyzer.findNearestContour(i, j, dir, cvd);
        testID = "testFindNearest(" + dir + "):" + i + "," + j;
        assertEquals(testID, false, found);

    }

    @Test
    public void testFindNearestNE() throws Exception {
        testFindNearestMinor(SearchDir.NE);
    }

    @Test
    public void testFindNearestNW() throws Exception {
        testFindNearestMinor(SearchDir.NW);
    }

    @Test
    public void testFindNearestSE() throws Exception {
        testFindNearestMinor(SearchDir.SE);
    }

    @Test
    public void testFindNearestSW() throws Exception {
        testFindNearestMinor(SearchDir.SW);
    }

    private void testFindNearestMinor(SearchDir dir) {

        // Set up 2 lines to watch for diagonal leakage
        double lineAOriginX = Double.NaN;
        double lineAOriginY = Double.NaN;
        double lineBOriginX = Double.NaN;
        double lineBOriginY = Double.NaN;
        double lineALimitX = Double.NaN;
        double lineALimitY = Double.NaN;
        double lineBLimitX = Double.NaN;
        double lineBLimitY = Double.NaN;

        switch (dir) {
        case NE:
            lineAOriginX = 0.0;
            lineAOriginY = YDIM - 1;
            lineALimitX = XDIM - 1;
            lineALimitY = 0.0;
            lineBOriginX = XDIM / 2;
            lineBOriginY = YDIM - 1;
            lineBLimitX = XDIM - 1;
            lineBLimitY = YDIM / 2;
            break;
        case NW:
            lineAOriginX = 0.0;
            lineAOriginY = 0.0;
            lineALimitX = XDIM - 1;
            lineALimitY = YDIM - 1;
            lineBOriginX = 0.0;
            lineBOriginY = YDIM / 2;
            lineBLimitX = XDIM / 2;
            lineBLimitY = YDIM - 1;
            break;
        case SE:
            lineAOriginX = 0.0;
            lineAOriginY = 0.0;
            lineALimitX = XDIM - 1;
            lineALimitY = YDIM - 1;
            lineBOriginX = XDIM / 2;
            lineBOriginY = 0.0;
            lineBLimitX = XDIM - 1;
            lineBLimitY = YDIM / 2;
            break;
        case SW:
            lineAOriginX = 0.0;
            lineAOriginY = YDIM - 1;
            lineALimitX = XDIM - 1;
            lineALimitY = 0.0;
            lineBOriginX = 0.0;
            lineBOriginY = YDIM / 2;
            lineBLimitX = XDIM / 2;
            lineBLimitY = 0.0;
            break;
        default:
            fail("testFindNearestMinor: cannot work with direction " + dir);
        }

        // This is the contour we want to find
        Coordinate[] lineA = new Coordinate[2];
        lineA[0] = new Coordinate(lineAOriginX, lineAOriginY);
        lineA[1] = new Coordinate(lineALimitX, lineALimitY);
        // cseq = seqFactory.create(lineA);
        contourLevel = 10.0f;
        contour = new CLine(lineA, contourLevel, true);
        contours.add(contour);

        // This is the one we don't want to find
        Coordinate[] lineB = new Coordinate[2];
        lineB[0] = new Coordinate(lineBOriginX, lineBOriginY);
        lineB[1] = new Coordinate(lineBLimitX, lineBLimitY);
        // cseq = seqFactory.create(lineB);
        contourLevel = 999;
        contour = new CLine(lineB, contourLevel, true);
        contours.add(contour);

        // Create the analyzer and prime it for findNearestContour() calls.
        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);

        int i = Integer.MIN_VALUE;
        int j = Integer.MIN_VALUE;
        int deltai = Integer.MIN_VALUE;
        int deltaj = Integer.MIN_VALUE;

        switch (dir) {
        case NE:
            i = XDIM / 2 - 2;
            j = YDIM / 2 - 1;
            deltai = -1;
            deltaj = 0;
            break;
        case NW:
            i = XDIM / 2 + 1;
            j = YDIM / 2 - 1;
            deltai = 1;
            deltaj = 0;
            break;
        case SE:
            i = XDIM / 2 - 1;
            j = YDIM / 2 + 1;
            deltai = -1;
            deltaj = 0;
            break;
        case SW:
            i = XDIM / 2 + 1;
            j = XDIM / 2;
            deltai = 1;
            deltaj = 0;
            break;
        }

        String testID;
        testID = "testFindNearest(" + dir + "):" + i + "," + j;

        boolean found;
        ContourValueDistance cvd = new ContourValueDistance();
        found = analyzer.findNearestContour(i, j, dir, cvd);

        assertEquals(testID, true, found);
        assertEquals(testID, 10.0, cvd.value);
        // findNearestContour() uses 2 approximations for diagonal distance.
        // The first is about sqrt(2.0) times n steps.
        // The second is the same minus 0.414 when it avoids diagonal leakage.
        assertTrue(testID, (SUBGRID_FACTOR * 1.414 == cvd.distance)
                || (SUBGRID_FACTOR * 1.414 - 0.414 == cvd.distance));

        i += deltai;
        j += deltaj;
        testID = "testFindNearest(" + dir + "):" + i + "," + j;
        found = analyzer.findNearestContour(i, j, dir, cvd);
        assertEquals(testID, true, found);
        assertEquals(testID, 10.0, cvd.value);
        assertEquals(testID, SUBGRID_FACTOR * 1.5 * 1.414, cvd.distance);
        assertTrue(testID, (SUBGRID_FACTOR * 1.5 * 1.414 == cvd.distance)
                || (SUBGRID_FACTOR * 1.5 * 1.414 - 0.414 == cvd.distance));

        i += deltai;
        j += deltaj;
        testID = "testFindNearest(" + dir + "):" + i + "," + j;
        found = analyzer.findNearestContour(i, j, dir, cvd);
        assertEquals(testID, true, found);
        assertEquals(testID, 10.0, cvd.value);
        assertEquals(testID, SUBGRID_FACTOR * 2 * 1.414, cvd.distance);
        assertTrue(testID, (SUBGRID_FACTOR * 2 * 1.414 == cvd.distance)
                || (SUBGRID_FACTOR * 2 * 1.414 - 0.414 == cvd.distance));

    }

    @Test
    public void testFindDistantN() throws Exception {
        testFindDistantMajor(SearchDir.N);
    }

    @Test
    public void testFindDistantS() throws Exception {
        testFindDistantMajor(SearchDir.S);
    }

    @Test
    public void testFindDistantE() throws Exception {
        testFindDistantMajor(SearchDir.E);
    }

    @Test
    public void testFindDistantW() throws Exception {
        testFindDistantMajor(SearchDir.W);
    }

    private void testFindDistantMajor(SearchDir dir) throws Exception {

        double lineAOriginX = Double.NaN;
        double lineAOriginY = Double.NaN;
        double lineBOriginX = Double.NaN;
        double lineBOriginY = Double.NaN;
        double lineCOriginX = Double.NaN;
        double lineCOriginY = Double.NaN;
        double lineALimitX = Double.NaN;
        double lineALimitY = Double.NaN;
        double lineBLimitX = Double.NaN;
        double lineBLimitY = Double.NaN;
        double lineCLimitX = Double.NaN;
        double lineCLimitY = Double.NaN;

        switch (dir) {
        case N:
            lineAOriginX = 0.0;
            lineAOriginY = YDIM / 4;
            lineALimitX = XDIM - 1;
            lineALimitY = YDIM / 4;
            lineBOriginX = 0.0;
            lineBOriginY = YDIM / 2;
            lineBLimitX = XDIM - 1;
            lineBLimitY = YDIM / 2;
            lineCOriginX = 0.0;
            lineCOriginY = YDIM * 3 / 4;
            lineCLimitX = XDIM - 1;
            lineCLimitY = YDIM * 3 / 4;
            break;
        case S:
            lineAOriginX = 0.0;
            lineAOriginY = (YDIM - 1) - YDIM / 4;
            lineALimitX = XDIM - 1;
            lineALimitY = (YDIM - 1) - YDIM / 4;
            lineBOriginX = 0.0;
            lineBOriginY = (YDIM - 1) - YDIM / 2;
            lineBLimitX = XDIM - 1;
            lineBLimitY = (YDIM - 1) - YDIM / 2;
            lineCOriginX = 0.0;
            lineCOriginY = (YDIM - 1) - YDIM * 3 / 4;
            lineCLimitX = XDIM - 1;
            lineCLimitY = (YDIM - 1) - YDIM * 3 / 4;
            break;
        case E:
            lineAOriginX = XDIM / 4;
            lineAOriginY = 0.0;
            lineALimitX = XDIM / 4;
            lineALimitY = YDIM - 1;
            lineBOriginX = XDIM / 2;
            lineBOriginY = 0.0;
            lineBLimitX = XDIM / 2;
            lineBLimitY = YDIM - 1;
            lineCOriginX = 3 * XDIM / 4;
            lineCOriginY = 0.0;
            lineCLimitX = 3 * XDIM / 4;
            lineCLimitY = YDIM - 1;
            break;
        case W:
            lineAOriginX = (XDIM - 1) - XDIM / 4;
            lineAOriginY = 0.0;
            lineALimitX = (XDIM - 1) - XDIM / 4;
            lineALimitY = YDIM - 1;
            lineBOriginX = (XDIM - 1) - XDIM / 2;
            lineBOriginY = 0;
            lineBLimitX = (XDIM - 1) - XDIM / 2;
            lineBLimitY = YDIM - 1;
            lineCOriginX = (XDIM - 1) - XDIM * 3 / 4;
            lineCOriginY = 0.0;
            lineCLimitX = (XDIM - 1) - XDIM * 3 / 4;
            lineCLimitY = YDIM - 1;
            break;
        default:
            fail("testFindDistantMajor: cannot work with direction " + dir);
        }

        Coordinate[] lineA = new Coordinate[2];
        lineA[0] = new Coordinate(lineAOriginX, lineAOriginY);
        lineA[1] = new Coordinate(lineALimitX, lineALimitY);
        // cseq = seqFactory.create(lineA);
        contourLevel = 10.0f;
        contour = new CLine(lineA, contourLevel, true);
        contours.add(contour);

        Coordinate[] lineB = new Coordinate[2];
        lineB[0] = new Coordinate(lineBOriginX, lineBOriginY);
        lineB[1] = new Coordinate(lineBLimitX, lineBLimitY);
        // cseq = seqFactory.create(lineB);
        contourLevel = 15.0f;
        contour = new CLine(lineB, contourLevel, true);
        contours.add(contour);

        Coordinate[] lineC = new Coordinate[2];
        lineC[0] = new Coordinate(lineCOriginX, lineCOriginY);
        lineC[1] = new Coordinate(lineCLimitX, lineCLimitY);
        // cseq = seqFactory.create(lineC);
        contourLevel = 999.0f;
        contour = new CLine(lineC, contourLevel, true);
        contours.add(contour);

        // Create the analyzer and prime it for findDistantContour() calls.
        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);

        int i = Integer.MIN_VALUE;
        int j = Integer.MIN_VALUE;

        switch (dir) {
        case N:
            i = 0;
            j = 0;
            break;
        case S:
            i = 0;
            j = YDIM - 1;
            break;
        case E:
            i = 0;
            j = 0;
            break;
        case W:
            i = XDIM - 1;
            j = 0;
            break;
        }

        ContourValueDistance cvd1 = new ContourValueDistance();
        ContourValueDistance cvd2 = new ContourValueDistance();
        int numcFound = analyzer.findDistantContours(i, j, dir, cvd1, cvd2);

        String testID = "testFindDistantMajor(" + dir + "):" + i + "," + j;
        assertEquals(testID + "<num>", 2, numcFound);
        assertEquals(testID + "<v1>", 10.0, cvd1.value);
        assertEquals(testID + "<v2>", 15.0, cvd2.value);
        assertEquals(testID + "<d1>", SUBGRID_FACTOR * (YDIM / 4),
                cvd1.distance);
        assertEquals(testID + "<d2>", SUBGRID_FACTOR * (YDIM / 2),
                cvd2.distance);

        switch (dir) {
        case N:
            i = 0;
            j = YDIM / 4 + 1;
            break;
        case S:
            i = 0;
            j = (YDIM - 1) - (YDIM / 4 + 1);
            break;
        case E:
            i = XDIM / 4 + 1;
            j = 0;
            break;
        case W:
            i = (YDIM - 1) - (XDIM / 4 + 1);
            j = 0;
            break;
        }

        numcFound = analyzer.findDistantContours(i, j, dir, cvd1, cvd2);
        testID = "testFindDistantMajor(" + dir + "):" + i + "," + j;

        assertEquals(testID + "<num>", 2, numcFound);
        assertEquals(testID + "<v1>", 15.0, cvd1.value);
        assertEquals(testID + "<v2>", 999.0, cvd2.value);
        assertEquals(testID + "<d1>", SUBGRID_FACTOR
                * (YDIM / 2 - (YDIM / 4 + 1)), cvd1.distance);
        assertEquals(testID + "<d2>", SUBGRID_FACTOR
                * (3 * YDIM / 4 - (YDIM / 4 + 1)), cvd2.distance);

        switch (dir) {
        case N:
            i = 0;
            j = YDIM / 2 + 1;
            break;
        case S:
            i = 0;
            j = (YDIM - 1) - (YDIM / 2 + 1);
            break;
        case E:
            i = XDIM / 2 + 1;
            j = 0;
            break;
        case W:
            i = (XDIM - 1) - (XDIM / 2 + 1);
            j = 0;
            break;
        }

        numcFound = analyzer.findDistantContours(i, j, dir, cvd1, cvd2);
        testID = "testFindDistantMajor(" + dir + "):" + i + "," + j;

        // Even though there's a grid between i,j and the edge,
        // the routine should return 0 because no edge points have values set.
        assertEquals(testID + "<num>", 0, numcFound);

        // TODO: set edge points (how?), confirm rtnval, cvd1 and cvd2

        switch (dir) {
        case N:
            i = 0;
            j = YDIM * 3 / 4 + 1;
            break;
        case S:
            i = 0;
            j = (YDIM - 1) - (YDIM * 3 / 4 + 1);
            break;
        case E:
            i = XDIM * 3 / 4 + 1;
            j = 0;
            break;
        case W:
            i = (XDIM - 1) - (XDIM * 3 / 4 + 1);
            j = 0;
            break;
        }

        numcFound = analyzer.findDistantContours(i, j, dir, cvd1, cvd2);
        testID = "testFindDistantMajor(" + dir + "):" + i + "," + j;

        assertEquals(testID + "<num>", 0, numcFound);
    }

    @Test
    public void testFindDistantNE() throws Exception {
        testFindDistantMinor(SearchDir.NE);
    }

    @Test
    public void testFindDistantSE() throws Exception {
        testFindDistantMinor(SearchDir.SE);
    }

    @Test
    public void testFindDistantSW() throws Exception {
        testFindDistantMinor(SearchDir.SW);
    }

    @Test
    public void testFindDistantNW() throws Exception {
        testFindDistantMinor(SearchDir.NW);
    }

    /**
     * Distance from point to a line segment in 2 dimensions.
     * 
     * @param x1
     * @param y1
     * @param x2
     * @param y2
     * @param px
     * @param py
     * @return distance
     */
    public double linePtDistance(double x1, double y1, double x2, double y2,
            double px, double py) {
        double lineXdiff = x2 - x1;
        double lineYdiff = y2 - y1;
        double term1 = lineXdiff * (y1 - py);
        double term2 = lineYdiff * (x1 - px);
        double top = Math.abs(term1 - term2);
        double lineLength = lineXdiff * lineXdiff + lineYdiff * lineYdiff;
        lineLength = Math.sqrt(lineLength);
        double distance = top / lineLength;
        return distance;
    }

    public void testFindDistantMinor(SearchDir dir) throws Exception {

        double lineAOriginX = Double.NaN;
        double lineAOriginY = Double.NaN;
        double lineBOriginX = Double.NaN;
        double lineBOriginY = Double.NaN;
        double lineCOriginX = Double.NaN;
        double lineCOriginY = Double.NaN;
        double lineALimitX = Double.NaN;
        double lineALimitY = Double.NaN;
        double lineBLimitX = Double.NaN;
        double lineBLimitY = Double.NaN;
        double lineCLimitX = Double.NaN;
        double lineCLimitY = Double.NaN;

        switch (dir) {
        case NE:
            lineAOriginX = 0;
            lineAOriginY = YDIM / 4;
            lineALimitX = XDIM / 4;
            lineALimitY = 0;
            lineBOriginX = 0;
            lineBOriginY = YDIM / 2;
            lineBLimitX = XDIM / 2;
            lineBLimitY = 0;
            lineCOriginX = 0;
            lineCOriginY = YDIM * 3 / 4;
            lineCLimitX = XDIM * 3 / 4;
            lineCLimitY = 0;
            break;
        case SE:
            lineAOriginX = 0;
            lineAOriginY = (YDIM - 1) - (YDIM / 4);
            lineALimitX = XDIM / 4;
            lineALimitY = YDIM - 1;
            lineBOriginX = 0;
            lineBOriginY = (YDIM - 1) - (YDIM / 2);
            lineBLimitX = XDIM / 2;
            lineBLimitY = YDIM - 1;
            lineCOriginX = 0;
            lineCOriginY = (YDIM - 1) - (YDIM * 3 / 4);
            lineCLimitX = XDIM * 3 / 4;
            lineCLimitY = YDIM - 1;
            break;
        case SW:
            lineAOriginX = (XDIM - 1) - (XDIM / 4);
            lineAOriginY = YDIM - 1;
            lineALimitX = XDIM - 1;
            lineALimitY = (YDIM - 1) - (YDIM / 4);
            lineBOriginX = (XDIM - 1) - (XDIM / 2);
            lineBOriginY = YDIM - 1;
            lineBLimitX = XDIM - 1;
            lineBLimitY = (YDIM - 1) - (YDIM / 2);
            lineCOriginX = (XDIM - 1) - (XDIM * 3 / 4);
            lineCOriginY = YDIM - 1;
            lineCLimitX = XDIM - 1;
            lineCLimitY = (YDIM - 1) - (YDIM * 3 / 4);
            break;
        case NW:
            lineAOriginX = (XDIM - 1) - (XDIM / 4);
            lineAOriginY = 0;
            lineALimitX = XDIM - 1;
            lineALimitY = YDIM / 4;
            lineBOriginX = (XDIM - 1) - (XDIM / 2);
            lineBOriginY = 0;
            lineBLimitX = XDIM - 1;
            lineBLimitY = YDIM / 2;
            lineCOriginX = (XDIM - 1) - (XDIM * 3 / 4);
            lineCOriginY = 0;
            lineCLimitX = XDIM - 1;
            lineCLimitY = YDIM * 3 / 4;
            break;

        default:
            fail("testFindDistantMinor: cannot work with direction " + dir);
        }

        Coordinate[] lineA = new Coordinate[2];
        lineA[0] = new Coordinate(lineAOriginX, lineAOriginY);
        lineA[1] = new Coordinate(lineALimitX, lineALimitY);
        // cseq = seqFactory.create(lineA);
        contourLevel = 10.0f;
        contour = new CLine(lineA, contourLevel, true);
        contours.add(contour);

        Coordinate[] lineB = new Coordinate[2];
        lineB[0] = new Coordinate(lineBOriginX, lineBOriginY);
        lineB[1] = new Coordinate(lineBLimitX, lineBLimitY);
        // cseq = seqFactory.create(lineB);
        contourLevel = 15.0f;
        contour = new CLine(lineB, contourLevel, true);
        contours.add(contour);

        Coordinate[] lineC = new Coordinate[2];
        lineC[0] = new Coordinate(lineCOriginX, lineCOriginY);
        lineC[1] = new Coordinate(lineCLimitX, lineCLimitY);
        // cseq = seqFactory.create(lineC);
        contourLevel = 999.0f;
        contour = new CLine(lineC, contourLevel, true);
        contours.add(contour);

        // Create the analyzer and prime it for findDistantContour() calls.
        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);

        int i = Integer.MIN_VALUE;
        int j = Integer.MIN_VALUE;

        switch (dir) {
        case NE:
            i = 0;
            j = 0;
            break;
        case SE:
            i = 0;
            j = YDIM - 1;
            break;
        case SW:
            i = XDIM - 1;
            j = XDIM - 1;
            break;
        case NW:
            i = XDIM - 1;
            j = 0;
            break;
        }

        ContourValueDistance cvd1 = new ContourValueDistance();
        ContourValueDistance cvd2 = new ContourValueDistance();
        int numcFound = analyzer.findDistantContours(i, j, dir, cvd1, cvd2);

        String testID = "testFindDistantMinor(" + dir + "):" + i + "," + j;
        assertEquals(testID + "<num>", 2, numcFound);
        assertEquals(testID + "<v1>", 10.0, cvd1.value);
        assertEquals(testID + "<v2>", 15.0, cvd2.value);

        double expectedD1 = linePtDistance(lineAOriginX, lineAOriginY,
                lineALimitX, lineALimitY, i, j);
        expectedD1 *= SUBGRID_FACTOR;
        assertEquals(testID + "<d1>", expectedD1, cvd1.distance);
        double expectedD2 = linePtDistance(lineBOriginX, lineBOriginY,
                lineBLimitX, lineBLimitY, i, j);
        expectedD2 *= SUBGRID_FACTOR;
        assertEquals(testID + "<d2>", expectedD2, cvd2.distance);

        switch (dir) {
        case NE:
            i = 1;
            j = 0;
            break;
        case SE:
            i = 1;
            j = YDIM - 1;
            break;
        case SW:
            i = XDIM - 2;
            j = YDIM - 1;
            break;
        case NW:
            i = XDIM - 2;
            j = 0;
            break;
        }

        numcFound = analyzer.findDistantContours(i, j, dir, cvd1, cvd2);
        testID = "testFindDistantMinor(" + dir + "):" + i + "," + j;
        assertEquals(testID + "<num>", 2, numcFound);
        assertEquals(testID + "<v1>", 10.0, cvd1.value);
        assertEquals(testID + "<v2>", 15.0, cvd2.value);

        expectedD1 = linePtDistance(lineAOriginX, lineAOriginY, lineALimitX,
                lineALimitY, i, j);
        expectedD1 *= SUBGRID_FACTOR;
        assertEquals(testID + "<d1>", expectedD1, cvd1.distance);
        expectedD2 = linePtDistance(lineBOriginX, lineBOriginY, lineBLimitX,
                lineBLimitY, i, j);
        expectedD2 *= SUBGRID_FACTOR;
        assertEquals(testID + "<d2>", expectedD2, cvd2.distance);

        switch (dir) {
        case NE:
            i = XDIM / 4 + 1;
            j = 0;
            break;
        case SE:
            i = XDIM / 4 + 1;
            j = YDIM - 1;
            break;
        case SW:
            i = (XDIM - 1) - (XDIM / 4 + 1);
            j = YDIM - 1;
            break;
        case NW:
            i = (XDIM - 1) - (XDIM / 4 + 1);
            j = 0;
            break;
        }

        numcFound = analyzer.findDistantContours(i, j, dir, cvd1, cvd2);
        testID = "testFindDistantMinor(" + dir + "):" + i + "," + j;
        assertEquals(testID + "<num>", 2, numcFound);
        assertEquals(testID + "<v1>", 15.0, cvd1.value);
        assertEquals(testID + "<v2>", 999.0, cvd2.value);

        expectedD1 = linePtDistance(lineBOriginX, lineBOriginY, lineBLimitX,
                lineBLimitY, i, j);
        expectedD1 *= SUBGRID_FACTOR;
        assertEquals(testID + "<d1>", expectedD1, cvd1.distance);
        expectedD2 = linePtDistance(lineCOriginX, lineCOriginY, lineCLimitX,
                lineCLimitY, i, j);
        expectedD2 *= SUBGRID_FACTOR;
        assertEquals(testID + "<d2>", expectedD2, cvd2.distance);

        switch (dir) {
        case NE:
            i = XDIM / 2 + 1;
            j = 0;
            break;
        case SE:
            i = XDIM / 2 + 1;
            j = YDIM - 1;
            break;
        case SW:
            i = (XDIM - 1) - (XDIM / 2 + 1);
            j = YDIM - 1;
            break;
        case NW:
            i = (XDIM - 1) - (XDIM / 2 + 1);
            j = 0;
            break;
        }

        numcFound = analyzer.findDistantContours(i, j, dir, cvd1, cvd2);
        testID = "testFindDistantMinor(" + dir + "):" + i + "," + j;
        assertEquals(testID + "<num>", 0, numcFound);

    }

    @Test
    public void testFindAdjacentN() throws Exception {
        testFindAdjacent(SearchDir.N);
    }

    @Test
    public void testFindAdjacentS() throws Exception {
        testFindAdjacent(SearchDir.S);
    }

    @Test
    public void testFindAdjacentE() throws Exception {
        testFindAdjacent(SearchDir.E);
    }

    @Test
    public void testFindAdjacentW() throws Exception {
        testFindAdjacent(SearchDir.W);
    }

    @Test
    public void testFindAdjacentNE() throws Exception {
        testFindAdjacent(SearchDir.NE);
    }

    @Test
    public void testFindAdjacentSE() throws Exception {
        testFindAdjacent(SearchDir.SE);
    }

    @Test
    public void testFindAdjacentSW() throws Exception {
        testFindAdjacent(SearchDir.SW);
    }

    @Test
    public void testFindAdjacentNW() throws Exception {
        testFindAdjacent(SearchDir.NW);
    }

    public void testFindAdjacent(SearchDir dir) throws Exception {

        int i = Integer.MIN_VALUE;
        int j = Integer.MIN_VALUE;

        switch (dir) {
        case N:
            xMin = 0;
            xMax = 0;
            yMin = 0;
            yMax = YDIM - 2;
            i = 0;
            j = 0;
            break;
        case S:
            xMin = 0;
            xMax = 0;
            yMin = 1;
            yMax = YDIM - 1;
            i = 0;
            j = YDIM - 1;
            break;
        case E:
            xMin = 0;
            xMax = XDIM - 2;
            yMin = 0;
            yMax = 0;
            i = 0;
            j = 0;
            break;
        case W:
            xMin = 1;
            xMax = XDIM - 1;
            yMin = 0;
            yMax = 0;
            i = XDIM - 1;
            j = 0;
            break;
        case NE:
            xMin = 0;
            yMin = 0;
            xMax = XDIM - 2;
            yMax = YDIM - 1;
            i = 0;
            j = 0;
            break;
        case SE:
            xMin = 0;
            xMax = XDIM - 2;
            yMin = 0;
            yMax = YDIM - 1;
            i = 0;
            j = YDIM - 1;
            break;
        case SW:
            xMin = 1;
            xMax = XDIM - 1;
            yMin = 0;
            yMax = YDIM - 1;
            i = XDIM - 1;
            j = YDIM - 1;
            break;
        case NW:
            xMin = 1;
            xMax = XDIM - 1;
            yMin = 0;
            yMax = YDIM - 1;
            i = XDIM - 1;
            j = 0;
            break;
        default:
            fail("Invalid search direction: " + dir);
        }

        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);
        analyzer.setSubGridFactor(SUBGRID_FACTOR);

        double expected = Double.MIN_VALUE;
        switch (dir) {
        case N:
            analyzer.howFound.set(0, YDIM - 1, 2);
            expected = -XDIM;
            break;
        case S:
            analyzer.howFound.set(0, 0, 2);
            expected = -(XDIM * YDIM);
            break;
        case E:
            analyzer.howFound.set(XDIM - 1, 0, 2);
            expected = -(XDIM * YDIM) + XDIM - 1;
            break;
        case W:
            analyzer.howFound.set(0, 0, 2);
            expected = -(XDIM * YDIM);
            break;
        case NE:
            analyzer.howFound.set(XDIM - 1, YDIM - 1, 2);
            expected = -1;
            break;
        case SE:
            analyzer.howFound.set(XDIM - 1, 0, 2);
            expected = -(XDIM * YDIM) + XDIM - 1;
            break;
        case SW:
            analyzer.howFound.set(0, 0, 2);
            expected = -(XDIM * YDIM);
            break;
        case NW:
            analyzer.howFound.set(0, YDIM - 1, 2);
            expected = -XDIM;
            break;
        }

        ContourValueDistance cvd = new ContourValueDistance();
        boolean found = analyzer.findAdjacentValue(i, j, dir, cvd);

        assertEquals("", true, found);
        assertEquals("", expected, cvd.value);
    }

    @Test
    public void testDoAnalysis() throws Exception {

        // Create a pair of narrow contours.
        // These will exercise
        Coordinate[] lineA = new Coordinate[3];
        lineA[0] = new Coordinate(XDIM / 2 + 1, 0);
        lineA[1] = new Coordinate(XDIM / 2 + 1, YDIM / 2 - 2);
        lineA[2] = new Coordinate(XDIM / 2 + 2, 0);
        // cseq = seqFactory.create(lineA);
        contourLevel = 6.0f;
        contour = new CLine(lineA, contourLevel, true);
        contours.add(contour);

        Coordinate[] lineB = new Coordinate[3];
        lineB[0] = new Coordinate(XDIM / 2 + 1, YDIM - 1);
        lineB[1] = new Coordinate(XDIM / 2 + 1, (YDIM - 1) - (YDIM / 2 - 2));
        lineB[2] = new Coordinate(XDIM / 2 + 2, YDIM - 1);
        // cseq = seqFactory.create(lineB);
        contourLevel = 12.0f;
        contour = new CLine(lineB, contourLevel, true);
        contours.add(contour);

        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);

        analyzer.doAnalysis();

        // confirm that they were set in the right way
        int[] howFound = analyzer.howFound.getBuffer().array();

        // Default for points that weren't copied from the contours or analyzed.
        int[] expectedHF = new int[100];
        Arrays.fill(expectedHF, -9);
        // These points should have been copied from the contours we supplied
        int[] contouredIndices = new int[] { 6, 7, 36, 66, 96, 97 };
        for (int i = 0; i < contouredIndices.length; i++) {
            expectedHF[contouredIndices[i]] = 9;
        }
        // These points should have been analyzed.
        int[] analyzedIndices = new int[] { 0, 10, 11, 17, 20, 21, 22, 27, 31,
                32, 33, 37, 39, 43, 44, 46, 47, 48, 49, 53, 54, 56, 57, 58, 59,
                61, 62, 63, 67, 69, 70, 71, 72, 77, 80, 81, 87, 90 };
        for (int i = 0; i < analyzedIndices.length; i++) {
            expectedHF[analyzedIndices[i]] = 1;
        }
        // Confirm that operations were carried out on the right set of points.
        assertArrayEquals(expectedHF, howFound);

        float[] analyzedValues = analyzer.finalResultData.getFloats();
        for (int i = 0; i < analyzedIndices.length; i++) {
            assertEquals("REGRESSIONDATA[" + analyzedIndices[i] + "]",
                    REGRESSIONDATA[analyzedIndices[i]],
                    analyzedValues[analyzedIndices[i]]);
        }

    }

    @Test
    public void testGridValueFromGradient() throws Exception {

        testDoAnalysis();
        analyzer.gridValueFromGradient();

        // confirm that they were set in the right way
        int[] howFound = analyzer.howFound.getBuffer().array();

        // Default for points that weren't copied from the contours or analyzed.
        int[] expectedHF = new int[100];
        Arrays.fill(expectedHF, -9);
        // These points should have been copied from the contours we supplied
        int[] contouredIndices = new int[] { 6, 7, 36, 66, 96, 97 };
        for (int i = 0; i < contouredIndices.length; i++) {
            expectedHF[contouredIndices[i]] = 9;
        }
        // These points should have been analyzed.
        int[] analyzedIndices = new int[] { 0, 10, 11, 17, 20, 21, 22, 27, 31,
                32, 33, 37, 39, 43, 44, 46, 47, 48, 49, 53, 54, 56, 57, 58, 59,
                61, 62, 63, 67, 69, 70, 71, 72, 77, 80, 81, 87, 90 };
        for (int i = 0; i < analyzedIndices.length; i++) {
            expectedHF[analyzedIndices[i]] = 1;
        }

        // These points should have been generated from a gradient.
        int[] gradientIndices = new int[] { 3, 9, 14, 16, 18, 25, 26, 30, 34,
                35, 38, 60, 64, 65, 68, 75, 76, 84, 86, 88, 93, 99 };
        for (int i = 0; i < gradientIndices.length; i++) {
            expectedHF[gradientIndices[i]] = 2;
        }

        // Confirm that operations were carried out on the right set of points.
        assertArrayEquals(expectedHF, howFound);

        // Confirm that points that were calculated by gridValueFromGradient()
        // match the output of the legacy system.
        float[] gradientValues = analyzer.finalResultData.getFloats();
        for (int i = 0; i < gradientIndices.length; i++) {
            assertEquals("expectedValue[" + gradientIndices[i] + "]",
                    REGRESSIONDATA[gradientIndices[i]],
                    gradientValues[gradientIndices[i]]);
        }

    }

    @Test
    public void testComputeShadowAreas() throws Exception {
        testGridValueFromGradient();
        analyzer.computeShadowAreas();

        // All points should have been computed by now.
        // All the -9s in testGridValueFromGradient should be 3s in this step.
        int[] expectedHF = new int[100];
        Arrays.fill(expectedHF, 3);

        // Now override the same values we did in testGridValueFromGradient.
        // These points should have been copied from the contours we supplied
        int[] contouredIndices = new int[] { 6, 7, 36, 66, 96, 97 };
        for (int i = 0; i < contouredIndices.length; i++) {
            expectedHF[contouredIndices[i]] = 9;
        }
        // These points should have been analyzed.
        int[] analyzedIndices = new int[] { 0, 10, 11, 17, 20, 21, 22, 27, 31,
                32, 33, 37, 39, 43, 44, 46, 47, 48, 49, 53, 54, 56, 57, 58, 59,
                61, 62, 63, 67, 69, 70, 71, 72, 77, 80, 81, 87, 90 };
        for (int i = 0; i < analyzedIndices.length; i++) {
            expectedHF[analyzedIndices[i]] = 1;
        }

        // These points should have been generated from a gradient.
        int[] gradientIndices = new int[] { 3, 9, 14, 16, 18, 25, 26, 30, 34,
                35, 38, 60, 64, 65, 68, 75, 76, 84, 86, 88, 93, 99 };
        for (int i = 0; i < gradientIndices.length; i++) {
            expectedHF[gradientIndices[i]] = 2;
        }

        // Confirm that operations were carried out on the right set of points.
        int[] howFound = analyzer.howFound.getBuffer().array();
        assertArrayEquals("how-found", expectedHF, howFound);

        // since everything has been computed, finalResultData should
        // completely match the regression data from the legacy routine.
        float[] finalValues = analyzer.finalResultData.getFloats();
        for (int i = 0; i < REGRESSIONDATA.length; i++) {
            assertEquals("finalValues[" + i + "]", REGRESSIONDATA[i],
                    finalValues[i]);
        }
    }

    @Test
    public void testFullSize() throws Exception {

        originalGrid = new Grid2DFloat(XDIMBIG, YDIMBIG, -1.0f);

        // Writing the contours as code didn't work (64k limit), so parse jtext
        // to create the contours
        contours = ContourTextfileReader
                .readCoordinates("testdata/contours/jtext");

        contours.get(0).setModified(true);
        // contours are parsed!

        // Likewise, the expected output is too big to create inline in a static
        // block, so parse it, too.
        float[] expectedA = FloatArrayReader.read("testdata/contours/output",
                XDIMBIG * YDIMBIG);
        Grid2DFloat expected = new Grid2DFloat(XDIMBIG, YDIMBIG, expectedA);

        xMax = XDIMBIG;
        yMax = YDIMBIG;
        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);
        analyzer.recomputeGrid();
        result = analyzer.getFinalResultData();

        final float threshold = 0.01f;
        float expval;
        float actual;
        boolean failed = false;
        for (int i = 0; i < XDIMBIG; i++) {
            for (int j = 0; j < YDIMBIG; j++) {
                actual = result.get(i, j);
                expval = expected.get(i, j);
                if (Math.abs(actual - expval) > threshold) {
                    System.out.println("Grid discrepancy at (" + i + "," + j
                            + "): expected " + expval + " but value was "
                            + actual);
                    failed = true;
                }
            }
        }
        if (failed) {
            fail("Grid discrepancies were encountered. Consult output for details.");
        }
    }

    @Test
    public void testFullSize2() throws Exception {

        System.out.println("testFullSize2:");
        originalGrid = new Grid2DFloat(XDIMBIG, YDIMBIG, -1.0f);

        // Writing the contours as code didn't work (64k limit), so parse jtext
        // to create the contours
        contours = ContourTextfileReader
                .readCoordinates("testdata/contours/jtext2");

        contours.get(0).setModified(true);
        // contours are parsed!

        // Likewise, the expected output is too big to create inline in a static
        // block, so parse it, too.
        float[] expectedA = FloatArrayReader.read("testdata/contours/output2",
                XDIMBIG * YDIMBIG);
        Grid2DFloat expected = new Grid2DFloat(XDIMBIG, YDIMBIG, expectedA);

        xMax = XDIMBIG;
        yMax = YDIMBIG;
        analyzer = new ContourAnalyzer(originalGrid, contours, xOrigin,
                yOrigin, xGridRatio, yGridRatio, xMin, xMax, yMin, yMax,
                clampOn, valMax, valMin);
        analyzer.recomputeGrid();
        result = analyzer.getFinalResultData();

        final float threshold = 0.01f;
        float expval;
        float actual;
        boolean failed = false;
        for (int i = 0; i < XDIMBIG; i++) {
            for (int j = 0; j < YDIMBIG; j++) {
                actual = result.get(i, j);
                expval = expected.get(i, j);
                if (Math.abs(actual - expval) > threshold) {
                    System.out.println("Grid discrepancy at (" + i + "," + j
                            + "): expected " + expval + " but value was "
                            + actual);
                    failed = true;
                }
            }
        }
        if (failed) {
            fail("Grid discrepancies were encountered. Consult output for details.");
        }
    }
}