Application: gvSIG desktop

package org.gvsig.raster.lib.buffer.statistics;

import java.util.Arrays;

import java.util.Iterator;

import org.gvsig.raster.lib.buffer.api.Band;

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.BufferManager;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.api.statistics.Statistics;

import org.gvsig.raster.lib.buffer.api.statistics.StatisticsBand;

import org.gvsig.raster.lib.buffer.impl.MemoryBandDouble;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.task.SimpleTaskStatus;

public class DefaultStatisticsTest extends AbstractLibraryAutoInitTestCase {

    private final int BUFFER_ROWS = 1;

    private final int BUFFER_COLUMNS = 10;

    private final Number defaultNoDataValue = 10;

    private final Number noDataValue = 20;

    private Buffer testBuffer = null;

    private byte[] byteData = new byte[] { -86, 72, 102, -70, -3, -59, -36, 76, 66, 20 };

    private short[] shortData = new short[] { 13660, 6418, 4188, -8738, -31251, 17833, 12417,

        -10285, 31954, -8976 };

    private int[] intData =

        new int[] { 5, 478564, 427, 7647, 7885, -7841, 4523, 3478, -4555247, 0 };

    private float[] floatData = new float[] { -447.757514f, 1.45277f, 41.457276f,457.678547f,520f,575f,625f,653f,705f,999f};

    private double[] doubleData = new double[] { -43d, 1.45277d, 41.457276d,457.678547d,520d,575d,625d,653d,705d,999d};

    private int[] bandDataTypes =

        new int[] {

        BufferManager.TYPE_BYTE,

        BufferManager.TYPE_SHORT,

        BufferManager.TYPE_INT,

        BufferManager.TYPE_FLOAT,

        BufferManager.TYPE_DOUBLE

        };

    private Statistics statistics = null;

    @Override

    protected void doSetUp() throws Exception {

        NoData[] bandNodata = new NoData[6];

        BufferManager bufferManager = BufferLocator.getBufferManager();

        Arrays.fill(bandNodata,

            bufferManager.createNoData(noDataValue, defaultNoDataValue));

        testBuffer =

            bufferManager.createBuffer(BUFFER_ROWS, BUFFER_COLUMNS,

                bandDataTypes, bandNodata, null, null);

        testBuffer.getBand(0).putRow(0, byteData);

        testBuffer.getBand(1).putRow(0, shortData);

        testBuffer.getBand(2).putRow(0, intData);

        testBuffer.getBand(3).putRow(0, floatData);

        testBuffer.getBand(4).putRow(0, doubleData);

        SimpleTaskStatus simpleTaskStatus =

            ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("test Statistics");

        statistics = testBuffer.getStatistics(simpleTaskStatus);

    }

    /**

     * Test get number of values

     */

    public void testGetNumberOfValues() {

        long[] numberOfValues = statistics.getNumberOfValues();

        for (int i = 0; i < numberOfValues.length; i++) {

            assertEquals(BUFFER_ROWS * BUFFER_COLUMNS, numberOfValues[i]);

        }

    }

    /**

     * Test get max operation

     */

    public void testGetMax() {

        double[] max = statistics.getMax();

        assertTrue(equalsDouble(253, max[0]));

        assertTrue(equalsDouble(31954d, max[1]));

        assertTrue(equalsDouble(478564d, max[2]));

        assertTrue(equalsDouble(999d, max[3]));

        assertTrue(equalsDouble(999d, max[4]));

    }

    public void testGetSecondMax() {

        double[] secondMax = statistics.getSecondMax();

        assertTrue(equalsDouble(220, secondMax[0]));

        assertTrue(equalsDouble(17833d, secondMax[1]));

        assertTrue(equalsDouble(7885d, secondMax[2]));

        assertTrue(equalsDouble(705d, secondMax[3]));

        assertTrue(equalsDouble(705d, secondMax[4]));

    }

    public void testGetSecondMin() {

        double[] secondMax = statistics.getSecondMin();

        assertTrue(equalsDouble(66, secondMax[0]));

        assertTrue(equalsDouble(-10285d, secondMax[1]));

        assertTrue(equalsDouble(-7841d, secondMax[2]));

        assertTrue(equalsDouble(1.45277d, secondMax[3]));

        assertTrue(equalsDouble(1.45277d, secondMax[4]));

    }

    public void testGetMaximun() {

        double maximun = statistics.getMaximum();

        assertTrue(equalsDouble(478564d, maximun));

        assertTrue(statistics.isCalculated());

        testBuffer.getBand(4).set(0, 0, 525000d);

        Statistics newStatistics = testBuffer.getStatistics(null);

        assertTrue(statistics!=newStatistics);

        assertTrue(newStatistics.isCalculated());

        assertTrue(equalsDouble(525000d, newStatistics.getMaximum()));

    }

    public void testGetMinimun() {

        double minimun = statistics.getMinimum();

        assertTrue(equalsDouble(-4555247d, minimun));

    }

    public void testGetMean() {

        double[] mean = statistics.getMean();

        assertTrue(equalsDouble(136.2, mean[0]));

        assertTrue(equalsDouble(2722d, mean[1]));

        assertTrue(equalsDouble(-406055.9d, mean[2]));

        assertTrue(equalsDouble(412.98310964107515d, mean[3]));

        assertTrue(equalsDouble(453.45886037349703d, mean[4]));

    }

    public void testGetMedian() {

        double[] median = statistics.getMedian();

        assertTrue(equalsDouble(136, median[0]));

        assertTrue(equalsDouble(5303d, median[1]));

        assertTrue(equalsDouble(1952.5d, median[2]));

        assertTrue(equalsDouble(456.46593475341797d, median[3]));

        assertTrue(equalsDouble(530.1d, median[4]));

    }

    public void testGetMin() {

        double[] min = statistics.getMin();

        assertTrue(equalsDouble(20d, min[0]));

        assertTrue(equalsDouble(-31251d, min[1]));

        assertTrue(equalsDouble(-4555247d, min[2]));

        assertTrue(equalsDouble(-447.75750732421875d, min[3]));

        assertTrue(equalsDouble(-43d, min[4]));

    }

    public void testGetVariance() {

        double[] var = statistics.getVariance();

        assertTrue(equalsDouble(6147.733333333334d, var[0]));

        assertTrue(equalsDouble(3.226462408888889E8, var[1]));

        assertTrue(equalsDouble(2.1478555179265442E12, var[2]));

        assertTrue(equalsDouble(179912.41954150258, var[3]));

        assertTrue(equalsDouble(118875.01094268242, var[4]));

    }

    public void testGetBandCount() {

        assertEquals(bandDataTypes.length, testBuffer.getBandCount());

    }

    public void testIsCalculated() {

        assertTrue(statistics.isCalculated());

    }

    public void testGetVarianceCovarianceMatrix() {

        double[][] varcov = statistics.getVarianceCovarianceMatrix();

        for(int i=0; i<varcov.length; i++){

            for(int j=0; j<varcov.length; j++){

                assertTrue(equalsDouble(varcov[i][j], varcov[j][i]));

            }

        }

        for(int i=0; i<varcov.length; i++){

            assertTrue(equalsDouble(varcov[i][i], statistics.getVariance()[i]));

        }

        double[][] prueba = {

             {6147.733333333334, 366.44444444440563, 3648.0666666709712, -2656.0444444444483, -2100.2222222222267},

             {366.44444444440563, 3.226462408888889E8, 6.0213913666666776E7, -1394641.8888888892, -903647.2222222224},

             {3648.0666666709712, 6.0213913666666776E7, 2.1478555179265442E12, -1.695740194333333E8, -1.513463968111111E8},

             {-2656.0444444444483, -1394641.8888888892, -1.695740194333333E8, 179912.41954150255, 141202.28325532677},

             {-2100.2222222222267, -903647.2222222224, -1.513463968111111E8, 141202.28325532677, 118875.01094268242}};

        for(int i=0; i<varcov.length; i++){

            for(int j=0; j<varcov.length; j++){

                assertTrue(equalsDouble(prueba[i][j], varcov[i][j]));

                assertTrue(equalsDouble(prueba[i][j], varcov[j][i]));

            }

        }

    }

    public void testGetTailTrimValueDouble() {

        double[][] tailTrimValueObj = statistics.getTailTrimValue(30d);

        assertTrue(equalsDouble(74.0d, tailTrimValueObj[0][0]));

        assertTrue(equalsDouble(191.5d, tailTrimValueObj[0][1]));

        assertTrue(equalsDouble(-8857.0d, tailTrimValueObj[1][0]));

        assertTrue(equalsDouble(13038.5d, tailTrimValueObj[1][1]));

        assertTrue(equalsDouble(2.5d, tailTrimValueObj[2][0]));

        assertTrue(equalsDouble(6085.0d, tailTrimValueObj[2][1]));

        assertTrue(equalsDouble(275.6212463378906d, tailTrimValueObj[3][0]));

        assertTrue(equalsDouble(637.3106231689453d, tailTrimValueObj[3][1]));

        assertTrue(equalsDouble(217.5d, tailTrimValueObj[4][0]));

        assertTrue(equalsDouble(634.3d, tailTrimValueObj[4][1]));

        assertTrue(equalsDouble(217.5d, tailTrimValueObj[4][0]));

        assertTrue(equalsDouble(634.3d, tailTrimValueObj[4][1]));

    }

    public void testGetTailTrimValueInt() {

        double[][] tailTrimValueObj = statistics.getTailTrimValue(3);

        assertTrue(equalsDouble(74d, tailTrimValueObj[0][0]));

        assertTrue(equalsDouble(191.5d, tailTrimValueObj[0][1]));

        assertTrue(equalsDouble(-8857.0d, tailTrimValueObj[1][0]));

        assertTrue(equalsDouble(13038.5d, tailTrimValueObj[1][1]));

        assertTrue(equalsDouble(2.5d, tailTrimValueObj[2][0]));

        assertTrue(equalsDouble(6085.0d, tailTrimValueObj[2][1]));

        assertTrue(equalsDouble(275.6212463378906d, tailTrimValueObj[3][0]));

        assertTrue(equalsDouble(637.3106231689453d, tailTrimValueObj[3][1]));

        assertTrue(equalsDouble(217.5d, tailTrimValueObj[4][0]));

        assertTrue(equalsDouble(634.3d, tailTrimValueObj[4][1]));

        assertTrue(equalsDouble(217.5d, tailTrimValueObj[4][0]));

        assertTrue(equalsDouble(634.3d, tailTrimValueObj[4][1]));

    }

    public void testIterator() {

        Iterator<Band> iterator = testBuffer.iterator();

        assertNotNull(iterator);

        int cont = 0;

        while(iterator.hasNext()){

            assertNotNull(iterator.next());

            cont++;

        }

        assertEquals(testBuffer.getBandCount(), cont);

        iterator = testBuffer.iterator();

        while(iterator.hasNext()){

            iterator.next();

            iterator.remove();

        }

        assertTrue(testBuffer.getBandCount() == 0);

    }

    private boolean equalsDouble(double a, double b) {

        if (Math.abs(a - b) < 0.00000001) {

            return true;

        }

        return false;

    }

    public void testBufferStatistics() {

        assertTrue(statistics.isCalculated());

        double[] otherDoubleData = new double[] { -0.5d, -0.4d, -0.3d, -0.2d, -0.1d, 0d, 0.1d, 0.2d, 0.3d, 0.4d};

        MemoryBandDouble band = new MemoryBandDouble(1, BUFFER_COLUMNS);

        band.putRow(0, otherDoubleData);

        assertTrue(statistics.getBandCount()==5);

        testBuffer.addBand(band);

        assertTrue(statistics.getBandCount()==5);

        Statistics newStatistics = testBuffer.getStatistics(null);

        assertFalse(statistics==newStatistics);

        assertTrue(newStatistics.isCalculated());

        assertTrue(newStatistics.getBandCount()==6);

    }

}