Subversion Repositories hibernate-spatial

package org.hibernatespatial.jts.geom;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.CoordinateSequence;
import com.vividsolutions.jts.geom.impl.CoordinateArraySequence;
import org.hibernatespatial.jts.geom.MeasuredCoordinate;
import org.hibernatespatial.jts.geom.MeasuredCoordinateArraySequence;
import org.hibernatespatial.jts.geom.MeasuredCoordinateSequence;
import org.hibernatespatial.jts.geom.MeasuredCoordinateSequenceFactory;
import org.junit.Test;

import static org.junit.Assert.*;

/**
 * @author Karel Maesen, Geovise BVBA
 *         creation-date: Nov 22, 2010
 */
public class TestMeasuredCoordinateSequence {


    private MeasuredCoordinateSequence seq;

    @Test
    public void test_constructor_size() {

        MeasuredCoordinateSequenceFactory mcsf = new MeasuredCoordinateSequenceFactory();
        seq = mcsf.create(2, 4);
        Coordinate c0 = new Coordinate(1, 2, 3);
        seq.setMeasuredCoordinate(0, new MeasuredCoordinate(c0, 4));
        Coordinate c1 = new Coordinate(5, 6, 7);
        seq.setMeasuredCoordinate(1, new MeasuredCoordinate(c1, 8));
        assertEquals(c0, seq.getCoordinate(0));
        assertEquals(4d, seq.getM(0), Math.ulp(4d));
        assertEquals(c1, seq.getCoordinate(1));
        assertEquals(8d, seq.getM(1), Math.ulp(8d));

        try {
            seq.setMeasuredCoordinate(2, new MeasuredCoordinate(c1, 8));
            fail();
        } catch (ArrayIndexOutOfBoundsException e) {
        }


    }

    @Test
    public void test_constructor_coordinate_array() {
        Coordinate[] coordinates = new Coordinate[]{
                new Coordinate(1, 1),
                new Coordinate(2, 3),
                new Coordinate(4, 5)
        };

        seq = new MeasuredCoordinateArraySequence(coordinates);
        assertEquals(coordinates.length, seq.size());
        assertEquals(4, seq.getDimension());
        assertEquals(4, seq.getOrdinate(2, CoordinateSequence.X), Math.ulp(4f));
        assertEquals(5, seq.getOrdinate(2, CoordinateSequence.Y), Math.ulp(5f));
        assertEquals(Double.NaN, seq.getOrdinate(2, CoordinateSequence.M), 0.1f);
        
        //test null parameter
        seq = new MeasuredCoordinateArraySequence((Coordinate[])null);
        assertEquals(0, seq.size());

    }

    @Test
    public void test_constructor_coordinateseq() {
        CoordinateSequence s = new CoordinateArraySequence(10);
        seq = new MeasuredCoordinateArraySequence(s);
        assertEquals(10, seq.size());

        MeasuredCoordinateSequence ms = new MeasuredCoordinateArraySequence(3);
        ms.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(1, 2, 1));
        ms.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(3, 4, 2));
        ms.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(5, 6, 3));
        seq = new MeasuredCoordinateArraySequence((CoordinateSequence) ms);

        assertEquals(1, seq.getOrdinate(0, CoordinateSequence.X), Math.ulp(10));
        assertEquals(2, seq.getOrdinate(0, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(0, CoordinateSequence.Z)));
        assertEquals(1, seq.getOrdinate(0, CoordinateSequence.M), Math.ulp(10));

        assertEquals(3, seq.getOrdinate(1, CoordinateSequence.X), Math.ulp(10));
        assertEquals(4, seq.getOrdinate(1, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(1, CoordinateSequence.Z)));
        assertEquals(2, seq.getOrdinate(1, CoordinateSequence.M), Math.ulp(10));

        assertEquals(5, seq.getOrdinate(2, CoordinateSequence.X), Math.ulp(10));
        assertEquals(6, seq.getOrdinate(2, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(2, CoordinateSequence.Z)));
        assertEquals(3, seq.getOrdinate(2, CoordinateSequence.M), Math.ulp(10));

        //test null paramater
        seq = new MeasuredCoordinateArraySequence((CoordinateSequence)null);
        assertEquals(0, seq.size());

    }

    @Test
    public void test_constructor_coordinateseq_doubles() {
        CoordinateSequence s = new CoordinateArraySequence(10);
        double[] measures = new double[10];
        seq = new MeasuredCoordinateArraySequence(s, measures);
        assertEquals(10, seq.size());

        try {
            double[] m2 = new double[8];
            seq = new MeasuredCoordinateArraySequence(s, m2);
            fail();
        } catch (IllegalArgumentException e) {
        }

        seq = new MeasuredCoordinateArraySequence((CoordinateSequence) null, null);
        assertEquals(0, seq.size());

        //test null paramater
        seq = new MeasuredCoordinateArraySequence((CoordinateSequence)null, null);
        assertEquals(0, seq.size());

    }

    @Test
    public void test_constructor_coordinates_doubles() {
        Coordinate[] s = new Coordinate[10];
        double[] measures = new double[10];
        seq = new MeasuredCoordinateArraySequence(s, measures);
        assertEquals(10, seq.size());

        try {
            double[] m2 = new double[8];
            seq = new MeasuredCoordinateArraySequence(s, m2);
            fail();
        } catch (IllegalArgumentException e) {
        }

        seq = new MeasuredCoordinateArraySequence((Coordinate[]) null, null);
        assertEquals(0, seq.size());

    }

    @Test
    public void test_constructor_measurecoordinateseq() {
        MeasuredCoordinateSequence ms = new MeasuredCoordinateArraySequence(3);
        ms.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(1, 2, 1));
        ms.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(3, 4, 2));
        ms.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(5, 6, 3));

        seq = new MeasuredCoordinateArraySequence(ms);
        assertEquals(1, seq.getOrdinate(0, CoordinateSequence.X), Math.ulp(10));
        assertEquals(2, seq.getOrdinate(0, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(0, CoordinateSequence.Z)));
        assertEquals(1, seq.getOrdinate(0, CoordinateSequence.M), Math.ulp(10));

        assertEquals(3, seq.getOrdinate(1, CoordinateSequence.X), Math.ulp(10));
        assertEquals(4, seq.getOrdinate(1, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(1, CoordinateSequence.Z)));
        assertEquals(2, seq.getOrdinate(1, CoordinateSequence.M), Math.ulp(10));

        assertEquals(5, seq.getOrdinate(2, CoordinateSequence.X), Math.ulp(10));
        assertEquals(6, seq.getOrdinate(2, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(2, CoordinateSequence.Z)));
        assertEquals(3, seq.getOrdinate(2, CoordinateSequence.M), Math.ulp(10));

        seq = new MeasuredCoordinateArraySequence((MeasuredCoordinateSequence) null);
        assertEquals(0, seq.size());
    }

    @Test
    public void test_constructor_measurecoordinates() {
        MeasuredCoordinate[] ms = new MeasuredCoordinate[3];
        ms[0] = MeasuredCoordinate.to2DM(1, 2, 1);
        ms[1] = MeasuredCoordinate.to2DM(3, 4, 2);
        ms[2] = MeasuredCoordinate.to2DM(5, 6, 3);

        seq = new MeasuredCoordinateArraySequence(ms);
        assertEquals(1, seq.getOrdinate(0, CoordinateSequence.X), Math.ulp(10));
        assertEquals(2, seq.getOrdinate(0, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(0, CoordinateSequence.Z)));
        assertEquals(1, seq.getOrdinate(0, CoordinateSequence.M), Math.ulp(10));

        assertEquals(3, seq.getOrdinate(1, CoordinateSequence.X), Math.ulp(10));
        assertEquals(4, seq.getOrdinate(1, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(1, CoordinateSequence.Z)));
        assertEquals(2, seq.getOrdinate(1, CoordinateSequence.M), Math.ulp(10));

        assertEquals(5, seq.getOrdinate(2, CoordinateSequence.X), Math.ulp(10));
        assertEquals(6, seq.getOrdinate(2, CoordinateSequence.Y), Math.ulp(10));
        assertTrue(Double.isNaN(seq.getOrdinate(2, CoordinateSequence.Z)));
        assertEquals(3, seq.getOrdinate(2, CoordinateSequence.M), Math.ulp(10));

        seq = new MeasuredCoordinateArraySequence((MeasuredCoordinate[]) null);
        assertEquals(0, seq.size());

    }

    @Test
    public void test_can_set_m_ordinates() {
        seq = new MeasuredCoordinateArraySequence(2);
        seq.setOrdinate(0, CoordinateSequence.X, 0);
        seq.setOrdinate(0, CoordinateSequence.Y, 1);
        seq.setOrdinate(0, CoordinateSequence.Z, 2);
        seq.setOrdinate(0, CoordinateSequence.M, 3);
        for (int i = 0; i < seq.getDimension(); i++) {
            assertEquals(i, seq.getOrdinate(0, i), Math.ulp(10));
        }
    }

    @Test
    public void test_if_on_create_m_ordinates_are_NaN() {
        seq = new MeasuredCoordinateArraySequence(2);
        seq.setOrdinate(0, CoordinateSequence.X, 0);
        seq.setOrdinate(0, CoordinateSequence.Y, 1);
        seq.setOrdinate(0, CoordinateSequence.Z, 2);
        assertTrue(Double.isNaN(seq.getOrdinate(0, CoordinateSequence.M)));
        assertTrue(Double.isNaN(seq.getM(0)));
    }


    @Test
    public void test_get_m() {
        seq = new MeasuredCoordinateArraySequence(2);
        seq.setOrdinate(0, CoordinateSequence.X, 0);
        seq.setOrdinate(0, CoordinateSequence.Y, 1);
        seq.setOrdinate(0, CoordinateSequence.Z, 2);
        seq.setOrdinate(0, CoordinateSequence.M, 3);
        assertEquals(0, seq.getX(0), Math.ulp(10d));
        assertEquals(1, seq.getY(0), Math.ulp(10d));
        assertEquals(2, seq.getZ(0), Math.ulp(10d));
        assertEquals(3, seq.getM(0), Math.ulp(10d));

    }

    @Test
    public void test_setCoordinateAndM() {
        seq = new MeasuredCoordinateArraySequence(2);
        seq.setMeasuredCoordinate(0, MeasuredCoordinate.to3DM(0, 1, 2, 3));
        for (int i = 0; i < seq.getDimension(); i++) {
            assertEquals(i, seq.getOrdinate(0, i), Math.ulp(10d));
        }

    }

    @Test
    public void test_test_copy_measured_coordinate_index_coordinate(){

        seq = new MeasuredCoordinateArraySequence(4);
        seq.setMeasuredCoordinate(2, MeasuredCoordinate.to3DM(0, 1, 2, 3));

        MeasuredCoordinate mCoordinate = new MeasuredCoordinate();

        seq.getMeasuredCoordinate(0, mCoordinate);
        assertEquals(0, mCoordinate.getX(), Math.ulp(10d));
        assertEquals(0, mCoordinate.getY(), Math.ulp(10d));
        assertEquals(Double.NaN, mCoordinate.getZ(), Math.ulp(10d));
        assertEquals(Double.NaN, mCoordinate.getM(), Math.ulp(10d));

        seq.getMeasuredCoordinate(2, mCoordinate);
        assertEquals(0, mCoordinate.getX(), Math.ulp(10d));
        assertEquals(1, mCoordinate.getY(), Math.ulp(10d));
        assertEquals(2, mCoordinate.getZ(), Math.ulp(10d));
        assertEquals(3, mCoordinate.getM(), Math.ulp(10d));


        seq.setMeasuredCoordinate(1, MeasuredCoordinate.to2D(0, 1));
        seq.getMeasuredCoordinate(1, mCoordinate);
        assertEquals(0, mCoordinate.getX(), Math.ulp(10d));
        assertEquals(1, mCoordinate.getY(), Math.ulp(10d));
        assertEquals(Double.NaN, mCoordinate.getZ(), Math.ulp(10d));
        assertEquals(Double.NaN, mCoordinate.getM(), Math.ulp(10d));

        seq.setMeasuredCoordinate(3, MeasuredCoordinate.to2DM(0, 1, 2));
        seq.getMeasuredCoordinate(3, mCoordinate);
        assertEquals(0, mCoordinate.getX(), Math.ulp(10d));
        assertEquals(1, mCoordinate.getY(), Math.ulp(10d));
        assertEquals(Double.NaN, mCoordinate.getZ(), Math.ulp(10d));
        assertEquals(2, mCoordinate.getM(), Math.ulp(10d));


    }

    @Test
    public void test_clone() {
        seq = new MeasuredCoordinateArraySequence(2);
        MeasuredCoordinate mc0 = MeasuredCoordinate.to3DM(0, 1, 2, 3);
        MeasuredCoordinate mc1 = MeasuredCoordinate.to3DM(4, 5, 6, 7);
        seq.setMeasuredCoordinate(0, mc0);
        seq.setMeasuredCoordinate(1, mc1);

        MeasuredCoordinateArraySequence cloned = (MeasuredCoordinateArraySequence) seq.clone();
        //check that clone has same values as original

        assertTrue(mc0.equals3DWithMeasure(cloned.getMeasuredCoordinate(0)));
        assertTrue(mc1.equals3DWithMeasure(cloned.getMeasuredCoordinate(1)));

        //check independence
        cloned.setOrdinate(0, CoordinateSequence.M, 10);
        cloned.setOrdinate(1, CoordinateSequence.M, 11);
        //check that clone has same values as original
        assertEquals(3, seq.getOrdinate(0, CoordinateSequence.M), Math.ulp(10d));
        assertEquals(7, seq.getOrdinate(1, CoordinateSequence.M), Math.ulp(10d));

        assertFalse(mc0.equals3DWithMeasure(cloned.getMeasuredCoordinate(0)));
        assertFalse(mc1.equals3DWithMeasure(cloned.getMeasuredCoordinate(1)));
    }

}