Application: gvSIG desktop

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

import java.util.Arrays;

import java.util.Iterator;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

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

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

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

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

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

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

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.exceptions.BandException;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

public class MemoryBufferTest extends AbstractLibraryAutoInitTestCase {

    private final int BUFFER_ROWS = 5;

    private final int BUFFER_COLUMNS = 5;

    private final Number defaultNoDataValue = 10;

    private final Number noDataValue = 20;

    private Buffer testBuffer = null;

    @Override

    protected void doSetUp() throws Exception {

        int[] bandDataTypes =

            new int[] { BufferManager.TYPE_BYTE, BufferManager.TYPE_SHORT, BufferManager.TYPE_INT, BufferManager.TYPE_FLOAT,

                BufferManager.TYPE_DOUBLE };

        NoData[] bandNodata = new NoData[6];

        Arrays.fill(bandNodata,

            BufferLocator.getBufferManager().createNoData(noDataValue, defaultNoDataValue));

        testBuffer =

            BufferLocator.getBufferManager().createBuffer(BUFFER_ROWS, BUFFER_COLUMNS,

                bandDataTypes, bandNodata, null, null);

    }

    /**

     * Test get statistics

     */

    public void testGetStatistics() {

        SimpleTaskStatus simpleTaskStatus =

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

        Statistics statistics = testBuffer.getStatistics(simpleTaskStatus);

        assertNotNull(statistics);

    }

    /**

     * Test iterator method

     */

    public void testIterator() {

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

        assertNotNull(iterator);

        int cont = 0;

        while (iterator.hasNext()) {

            assertNotNull(iterator.next());

            cont++;

        }

        assertEquals(5, cont);

    }

    /**

     * Test get band count

     */

    public void testGetBandCount() {

        assertEquals(5, testBuffer.getBandCount());

    }

    /**

     * Test get bands

     */

    public void testGetBands() {

        Band[] bands = testBuffer.getBands();

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

    }

    /**

     * Test get column method

     */

    public void testGetColumns() {

        assertEquals(BUFFER_COLUMNS, testBuffer.getColumns());

    }

    /**

     * Test get row method

     */

    public void testGetRows() {

        assertEquals(BUFFER_ROWS, testBuffer.getRows());

    }

    /**

     * Test is inside method

     */

    public void testIsInsideIntInt() {

        assertTrue(testBuffer.isInside(2, 2));

        assertFalse(testBuffer.isInside(10, 10));

        assertFalse(testBuffer.isInside(-5, -10));

    }

    /**

     * Test add band method

     */

    public void testAddBand() {

        Band band = null;

        Band wrongBand = null;

        try {

            band =

                BufferLocator.getBufferManager().createBand(BufferManager.TYPE_FLOAT, BUFFER_ROWS,

                    BUFFER_COLUMNS, null, null);

            wrongBand =

                BufferLocator.getBufferManager().createBand(BufferManager.TYPE_FLOAT,

                    BUFFER_ROWS * 2, BUFFER_COLUMNS * 2, null, null);

        } catch (LocatorException | BandException e) {

            fail("Can not create bands to test add band method");

        }

        testBuffer.addBand(band);

        Exception e = null;

        try {

            testBuffer.addBand(wrongBand);

        } catch (RuntimeException runtimeException) {

            // Expected exception

            e = runtimeException;

        }

        assertNotNull(e);

    }

    /**

     * Test set band method

     */

    public void testSetBand() {

        Band newBandByte = null;

        Band newBandDouble = null;

        try {

            newBandByte =

                BufferLocator.getBufferManager().createBand(BufferManager.TYPE_BYTE, BUFFER_ROWS,

                    BUFFER_COLUMNS, null, null);

            newBandDouble =

                BufferLocator.getBufferManager().createBand(BufferManager.TYPE_DOUBLE, BUFFER_ROWS,

                    BUFFER_COLUMNS, null, null);

        } catch (LocatorException | BandException e) {

            fail("Can not create band to set band to buffer");

        }

        try {

            testBuffer.setBand(0, newBandByte);

        } catch (BandException e) {

            fail("Cant not set new band to buffer");

        }

        assertEquals(5, testBuffer.getBandCount());

        Band band = testBuffer.getBand(0);

        for (int i = 0; i < band.getRows(); i++) {

            for (int j = 0; j < band.getColumns(); j++) {

                assertEquals(band.get(i, j), newBandByte.get(i, j));

            }

        }

        Exception e = null;

        try {

            testBuffer.setBand(0, newBandDouble);

        } catch (BandException exception) {

            // Expected exception

            e = exception;

        }

        assertNotNull(e);

    }

    /**

     * Test remove band method

     */

    public void testRemoveBand() {

        testBuffer.removeBand(0);

        assertEquals(4, testBuffer.getBandCount());

        testBuffer.removeBand(1);

        assertEquals(3, testBuffer.getBandCount());

    }

    /**

     * Test get band method

     */

    public void testGetBand() {

        Band band = testBuffer.getBand(0);

        assertNotNull(band);

        assertEquals(BufferManager.TYPE_BYTE, band.getDataType());

        band = testBuffer.getBand(4);

        assertEquals(BufferManager.TYPE_DOUBLE, band.getDataType());

    }

    /**

     * Test get band byte method

     */

    public void testGetBandByte() {

        BandByte bandByte = testBuffer.getBandByte(0);

        assertNotNull(bandByte);

        assertEquals(BufferManager.TYPE_BYTE, bandByte.getDataType());

        Exception e = null;

        try {

            testBuffer.getBandDouble(1);

        } catch (RuntimeException runtimeException) {

            // Expected exception

            e = runtimeException;

        }

        assertNotNull(e);

    }

    /**

     * Test get band short

     */

    public void testGetBandShort() {

        BandShort bandShort = testBuffer.getBandShort(1);

        assertNotNull(bandShort);

        assertEquals(BufferManager.TYPE_SHORT, bandShort.getDataType());

        Exception e = null;

        try {

            testBuffer.getBandDouble(0);

        } catch (RuntimeException runtimeException) {

            // Expected exception

            e = runtimeException;

        }

        assertNotNull(e);

    }

    /**

     * Test get band int

     */

    public void testGetBandInt() {

        BandInt bandInt = testBuffer.getBandInt(2);

        assertNotNull(bandInt);

        assertEquals(BufferManager.TYPE_INT, bandInt.getDataType());

        Exception e = null;

        try {

            testBuffer.getBandDouble(1);

        } catch (RuntimeException runtimeException) {

            // Expected exception

            e = runtimeException;

        }

        assertNotNull(e);

    }

    /**

     * Test get band float

     */

    public void testGetBandFloat() {

        BandFloat bandFloat = testBuffer.getBandFloat(3);

        assertNotNull(bandFloat);

        assertEquals(BufferManager.TYPE_FLOAT, bandFloat.getDataType());

        Exception e = null;

        try {

            testBuffer.getBandDouble(3);

        } catch (RuntimeException runtimeException) {

            // Expected exception

            e = runtimeException;

        }

        assertNotNull(e);

    }

    /**

     * Test get band double

     */

    public void testGetBandDouble() {

        BandDouble bandByte = testBuffer.getBandDouble(4);

        assertNotNull(bandByte);

        assertEquals(BufferManager.TYPE_DOUBLE, bandByte.getDataType());

        Exception e = null;

        try {

            testBuffer.getBandDouble(1);

        } catch (RuntimeException runtimeException) {

            // Expected exception

            e = runtimeException;

        }

        assertNotNull(e);

    }

    /**

     *

     */

    public void testSwitchBandsIntArray() {

        int[] positions = new int[] { 4, 2, 1, 3, 0 };

        testBuffer.switchBands(positions);

        assertEquals(testBuffer.getBand(0).getDataType(), BufferManager.TYPE_DOUBLE);

        assertEquals(testBuffer.getBand(1).getDataType(), BufferManager.TYPE_INT);

        assertEquals(testBuffer.getBand(2).getDataType(), BufferManager.TYPE_SHORT);

        assertEquals(testBuffer.getBand(3).getDataType(), BufferManager.TYPE_FLOAT);

        assertEquals(testBuffer.getBand(4).getDataType(), BufferManager.TYPE_BYTE);

    }

    /**

     * Test swing band method

     */

    public void testSwitchBandsIntInt() {

        Band oldBand = testBuffer.getBand(0);

        testBuffer.switchBands(0, 1);

        Band newBand = testBuffer.getBand(1);

        for (int i = 0; i < oldBand.getRows(); i++) {

            for (int j = 0; j < oldBand.getColumns(); j++) {

                assertEquals(oldBand.get(i, j), newBand.get(i, j));

            }

        }

        assertEquals(testBuffer.getBand(0).getDataType(), BufferManager.TYPE_SHORT);

        assertEquals(testBuffer.getBand(1).getDataType(), BufferManager.TYPE_BYTE);

    }

    public void testConvert() {

        int[] bandDataTypes =

            new int[] { BufferManager.TYPE_DOUBLE, BufferManager.TYPE_DOUBLE,

                BufferManager.TYPE_DOUBLE };

        NoData[] bandNodata = new NoData[3];

        Arrays.fill(bandNodata, BufferLocator.getBufferManager().createNoData(-99999d, -99999d));

        try {

            Envelope envelope =

                GeometryLocator.getGeometryManager().createEnvelope(625397.5, 4446997.5, 654602.5,

                    4466602.5, SUBTYPES.GEOM2D);

            IProjection projection = CRSFactory.getCRS("EPSG:25830");

            testBuffer =

                BufferLocator.getBufferManager().createBuffer(39, 58, bandDataTypes, bandNodata,

                    projection, envelope);

            ICoordTrans ct = projection.getCT(CRSFactory.getCRS("EPSG:4326"));

            Buffer projectedBuffer = testBuffer.convert(ct, null);

            assertEquals(testBuffer.getEnvelope().convert(ct), projectedBuffer.getEnvelope());

        } catch (CreateEnvelopeException | BufferException e) {

            fail("Can not create envelope or there are problems projecting buffers");

        }

    }

    public void testCreateInterpolated() {

        double[][] dataDouble =

            new double[][] { { 10, 10, 10, 10, 10 }, { 9, 9, 9, 9, 9 }, { 8, 8, 8, 8, 8 },

                { 6, 6, 6, 6, 6 }, { 1, 1, 1, 1, 1 } };

        Band band = testBuffer.getBand(4);

        for (int i = 0; i < band.getRows(); i++) {

            for (int j = 0; j < band.getColumns(); j++) {

                band.set(i, j, dataDouble[i][j]);

            }

        }

        Buffer interpolatedBuffer = null;

        try {

            interpolatedBuffer = testBuffer.createInterpolated(BUFFER_ROWS * 5, BUFFER_COLUMNS * 5,

                Buffer.INTERPOLATION_NearestNeighbour, null);

        } catch (LocatorException | BufferException e) {

            fail("Can not interpolate buffer");

        }

        assertEquals(testBuffer.getBandCount(), interpolatedBuffer.getBandCount());

        assertEquals(BUFFER_COLUMNS * 5, interpolatedBuffer.getColumns());

        assertEquals(BUFFER_ROWS * 5, interpolatedBuffer.getRows());

        assertTrue(Arrays.equals(testBuffer.getBandTypes(), interpolatedBuffer.getBandTypes()));

        assertTrue(Arrays.equals(testBuffer.getBandNoData(), interpolatedBuffer.getBandNoData()));

//        assertEquals(testBuffer.getEnvelope(), interpolatedBuffer.getEnvelope());

        assertEquals(testBuffer.getProjection(), interpolatedBuffer.getProjection());

    }

    public void testPixelSize() throws Exception {

        assertEquals(1d, testBuffer.getPixelSizeX());

        assertEquals(1d, testBuffer.getPixelSizeY());

        Buffer testBuffer2 = BufferLocator.getBufferManager().createBuffer(BUFFER_ROWS, BUFFER_COLUMNS,

            new int[] { BufferManager.TYPE_BYTE }, new NoData[1], null, GeometryLocator.getGeometryManager().createEnvelope(0d, 0d, 100d, 100d, Geometry.SUBTYPES.GEOM2D));

        assertEquals(20d, testBuffer2.getPixelSizeX());

        assertEquals(20d, testBuffer2.getPixelSizeY());

    }

}