| gvSIG desktop 1

package org.gvsig.data.datastores.vectorial.file.shp;

import java.awt.Shape;

import java.awt.geom.PathIterator;

import java.io.File;

import java.util.Date;

import java.util.Iterator;

import junit.framework.TestCase;

import org.apache.log4j.FileAppender;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.apache.log4j.PatternLayout;

import org.cresques.cts.IProjection;

import org.gvsig.compatible.StringUtil;

import org.gvsig.data.CloseException;

import org.gvsig.data.DataCollection;

import org.gvsig.data.DataManager;

import org.gvsig.data.DataStoreParameters;

import org.gvsig.data.InitializeException;

import org.gvsig.data.OpenException;

import org.gvsig.data.ReadException;

import org.gvsig.data.datastores.vectorial.file.shp.utils.SHP;

import org.gvsig.data.datastores.vectorial.file.shp_inst.InstSHPStore;

import org.gvsig.data.datastores.vectorial.file.shp_jni.JNISHPStore;

import org.gvsig.data.datastores.vectorial.file.shp_mem.MemSHPStore;

import org.gvsig.data.datastores.vectorial.file.shp_util.IGeometricDataStore;

import org.gvsig.data.datastores.vectorial.file.shp_util.ResourceReader;

import org.gvsig.data.datastores.vectorial.file.shp_util.Utils;

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.FeatureType;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.MultiCurve2D;

import org.gvsig.fmap.geom.aggregate.MultiPoint2D;

import org.gvsig.fmap.geom.aggregate.MultiSurface2D;

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

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

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

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

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateList;

import es.prodevelop.gvsig.mobile.fmap.driver.vect.shp.ShpReader;

/**

 * This class tests the three SHP drivers implemented for gvSIG Mobile.

 * These drivers are compatible with the new data access model (june 2008)

 * and will share a lot of code with gvsig Desktop.

 * 

 * The right testdata folder is needed.

 * 

 *  

 * @author jldominguez

 *

 */

public class SHPTest extends TestCase {

        private static Logger logger;

        /**

         * Test IDs

         */

        public static final int TEST_PUNTO = 0; 

        public static final int TEST_MPUNTO = 1; 

        public static final int TEST_LINEA = 2; 

        public static final int TEST_POLIGONO = 3; 

        public static final int TEST_NULL = 4; 

        public static final int TEST_ATT = 5; 

        private File filePunto, fileMPunto, fileLinea, filePoligono, fileNull, fileAtt;

        public SHPTest() {

                new Point2D();

                new MultiPoint2D((IProjection) null);

                new MultiCurve2D(null, null);

                new MultiSurface2D(null, null);

                new NullGeometry();

                ShpReader.touch();

                initLogger();

        }

        public static void main(String[] args) {

                junit.textui.TestRunner.run(SHPTest.class);

        }

        protected void setUp() throws Exception {

                super.setUp();

        }

        public void testInitialize() {

                if (Utils.USING_PDA) {

                        filePunto = ResourceReader.getPdaTestFile(PerformanceTest.SD_FOLDER, "testdata", "puntos_grande.shp");

                        fileMPunto = ResourceReader.getPdaTestFile(PerformanceTest.SD_FOLDER, "testdata", "multipuntos_grande.shp");

                        fileLinea = ResourceReader.getPdaTestFile(PerformanceTest.SD_FOLDER, "testdata", "lineas_grande.shp");

                        filePoligono = ResourceReader.getPdaTestFile(PerformanceTest.SD_FOLDER, "testdata", "poligonos_grande.shp");

                        fileNull = ResourceReader.getPdaTestFile(PerformanceTest.SD_FOLDER, "testdata", "pruebaNull.shp");

                        fileAtt = ResourceReader.getPdaTestFile(PerformanceTest.SD_FOLDER, "testdata", "atttest.shp");

                } else {

                        filePunto = ResourceReader.getResourceFile("testdata", "puntos_grande.shp");

                        fileMPunto = ResourceReader.getResourceFile("testdata", "multipuntos_grande.shp");

                        fileLinea = ResourceReader.getResourceFile("testdata", "lineas_grande.shp");

                        // fileLinea = ResourceReader.getResourceFile("testdata", "streets.shp");

                        filePoligono = ResourceReader.getResourceFile("testdata", "poligonos_grande.shp");

                        fileNull = ResourceReader.getResourceFile("testdata", "pruebaNull.shp");

                        fileAtt = ResourceReader.getResourceFile("testdata", "atttest.shp");

                }

                new SHPStore();

                doTest(SHPStore.DATASTORE_NAME);

                new MemSHPStore();

                doTest(MemSHPStore.DATASTORE_NAME);

                new JNISHPStore();

                doTest(JNISHPStore.DATASTORE_NAME);

                new InstSHPStore();

                doTest(InstSHPStore.DATASTORE_NAME);

                logger.debug("DONE.");

        }

        /**

         * Performs a test with a given data sorce name

         * 

         * @see SHPStore

         * @see MemSHPStore

         * @see JNISHPStore

         * 

         * @param ds_name

         */

        public void doTest(String ds_name) {

                logger.debug("DATASOURCE: " + ds_name + ", FILE = " + filePunto.getName() + "...");

                shp(filePunto, TEST_PUNTO, ds_name);

                if (ds_name.compareTo(JNISHPStore.DATASTORE_NAME) != 0) {

                        logger.debug("DATASOURCE: " + ds_name + ", FILE = " + fileMPunto.getName() + "...");

                        shp(fileMPunto, TEST_MPUNTO, ds_name);

                }

                logger.debug("DATASOURCE: " + ds_name + ", FILE = " + fileLinea.getName() + "...");

                shp(fileLinea, TEST_LINEA, ds_name);

                logger.debug("DATASOURCE: " + ds_name + ", FILE = " + filePoligono.getName() + "...");

                shp(filePoligono, TEST_POLIGONO, ds_name);

                logger.debug("DATASOURCE: " + ds_name + ", FILE = " + fileNull.getName() + "...");

                shp(fileNull, TEST_NULL, ds_name);

                logger.debug("DATASOURCE: " + ds_name + ", FILE = " + fileAtt.getName() + "...");

                shp(fileAtt, TEST_ATT, ds_name);

                // shp(fileGeometryNull);

        }

        private void shp(File file, int fileid, String datastore_name) {

                DataManager manager = DataManager.getManager();

                IGeometricDataStore store = null;

                SHPStoreParameters shpParameters=null;

                shpParameters =(SHPStoreParameters) manager.createDataStoreParameters(datastore_name);

                shpParameters.setFile(file);

                shpParameters.setDBFFile(SHP.getDbfFile(file));

                shpParameters.setSHXFile(SHP.getShxFile(file));

                shpParameters.setDataStoreName(datastore_name);

                try {

                        store = (IGeometricDataStore)

                        manager.createDataStore((DataStoreParameters)shpParameters);

                } catch (InitializeException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                try {

                        store.doOpen();

                } catch (OpenException e2) {

                        // TODO Auto-generated catch block

                        e2.printStackTrace();

                }

                FeatureType ft = store.getDefaultFeatureType();

                DataCollection dataCollection = null;

                try {

                        dataCollection = store.getDataCollection(ft,null,null);

                } catch (ReadException e1) {

                        e1.printStackTrace();

                }

                Iterator iter = dataCollection.iterator();

                int feature_count = 0;

                while (iter.hasNext()) {

                        Feature feature = (Feature)iter.next();

                        boolean simple = (datastore_name.compareTo(JNISHPStore.DATASTORE_NAME) == 0);

                        check(feature, ft, fileid, simple);

                        feature_count++;

                }

                iter=null;

                dataCollection.dispose();

                try {

                        store.doClose();

                        store.doDispose();

                } catch (CloseException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        private void check(Feature feature, FeatureType att_desc, int fileid, boolean simpletypes) {

                double expected = 0;

                switch (fileid) {

                case TEST_PUNTO:

                        expected = feature.getDouble("X");

                        Point2D p =  (Point2D) ((Geometry) feature.getDefaultGeometry()).getInternalShape();

                        checkPoint(feature, p, expected, simpletypes);

                        break;

                case TEST_MPUNTO:

                        checkMPoint(feature, simpletypes);

                        break;

                case TEST_LINEA:

                        expected = feature.getDouble("LEN");

                        Curve2D pl =  (Curve2D) ((Geometry) feature.getDefaultGeometry()).getInternalShape();

                        checkLineLength(feature, pl, expected, simpletypes);

                        break;

                case TEST_POLIGONO:

                        expected = feature.getDouble("AREA");

                        Surface2D pg =  (Surface2D) ((Geometry) feature.getDefaultGeometry()).getInternalShape();

                        checkPolygonArea(feature, pg, expected, simpletypes);

                        break;

                case TEST_NULL:

                        checkNullGeometry(feature);

                        break;

                case TEST_ATT:

                        checkAttributes(feature, simpletypes);

                        break;

                }

        }

        private void checkAttributes(Feature feat, boolean simpl) {

                if (! simpl) {

                        Date d = feat.getDate("ATT_DATE");

                        String str = d.toString().toLowerCase();

                        boolean boo =

                                ((str.indexOf("99") != -1)

                                        && (

                                                        (str.indexOf("12") != -1)

                                                        || (str.indexOf("dec") != -1)

                                                        || (str.indexOf("dic") != -1))

                                        && (str.indexOf("31") != -1));

                        assertTrue("Found a date different to 1999 12 31", boo);

                }

                String str = feat.getString("ATT_STRING").trim();

                assertEquals(str, "DFGDFGDFG");

                double real = feat.getDouble("ATT_REAL");

                boolean boo = ((real == 4.4444) || (real == 4));

                assertTrue("REAL = " + real + ", EXP = 4, 4.4444", boo);

                boolean bool = feat.getBoolean("ATT_BOOLEA");

                assertTrue("EXP = FALSE, RET = " + (!bool), !bool);

                int integ = 0;

                if (simpl) {

                        integ = (int) Math.round(feat.getDouble("ATT_INTEGE"));

                } else {

                        integ = feat.getInt("ATT_INTEGE");

                }

                assertTrue("REAL = " + integ + ", EXP = 44444", integ == 44444);

        }

        /**

         * Gets the area of the path iterator

         * @param piter the path iterator

         * @return the area of the path iterator

         */

        public static double getPathIteratorArea(PathIterator piter) {

                if (piter == null) {

                        return 0;

                }

                double resp = 0;

                double[] theData = new double[6];

                Coordinate c1 = null;

                Coordinate firstc = null;

                CoordinateList coordList = null;

                while (!piter.isDone()) {

                        int type = piter.currentSegment(theData);

                        if (type == PathIterator.SEG_MOVETO) {

                                if (coordList != null) {

                                        coordList.add(firstc, true);

                                        // printCoordList(coordList);

                                        resp = resp + CGAlgorithms.signedArea(coordList.toCoordinateArray());

                                }

                                firstc = new Coordinate(theData[0], theData[1]);

                                coordList = new CoordinateList();

                        }

                        c1 = new Coordinate(theData[0], theData[1]);

                        coordList.add(c1, true);

                        piter.next();

                }

                if (coordList != null) {

                        coordList.add(firstc, true);

                        // printCoordList(coordList);

                        // resp = resp + Math.abs(CGAlgorithms.signedArea(coordList.toCoordinateArray()));

                        resp = resp + CGAlgorithms.signedArea(coordList.toCoordinateArray());

                }

                return Math.abs(resp);

        }

        private void checkPolygonArea(Feature feature, Surface2D poly, double expected, boolean simpl) {

                int id = 0;

                if (simpl) {

                        id = (int) Math.round(feature.getDouble("GUIA_ID"));

                } else {

                        id = feature.getInt("GUIA_ID");

                }

                double ar = getPathIteratorArea(poly.getPathIterator(null));

                assertTrue("AREA = " + ar + ", EXP = " + expected, acceptablySimilar(expected, ar, 0.1));

                switch (id) {

                case 174996:

                        assertTrue("AREA = " + ar + ", EXP = " + 357.7, acceptablySimilar(ar, 357.7, 0.1));

                        break;

                case 569303133:

                        assertTrue("AREA = " + ar + ", EXP = " + 409.46, acceptablySimilar(ar, 409.46, 0.1));

                        break;

                case 1229222137:

                        assertTrue("AREA = " + ar + ", EXP = " + 49.285, acceptablySimilar(ar, 49.285, 0.1));

                        break;

                case 1795370359:

                        assertTrue("AREA = " + ar + ", EXP = " + 98.165, acceptablySimilar(ar, 98.165, 0.1));

                        break;

                }

        }

    /**

     * Gets the Euclidean distance between points A and B.

     * 

     * @param x1 x coordinate of point A

     * @param y1 y coordinate of point A

     * @param x2 x coordinate of point B

     * @param y2 y coordinate of point B

     * @return the Euclidean distance between points A and B.

     */

        public static double distance(double x1, double y1, double x2, double y2) {

                double dx = x2 - x1;

                double dy = y2 - y1;

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

        }

        /**

         * Gets the length of the path iterator and of the last of its arcs.

         * No SRS or unit conversion is used, just the plain length between coordinates.

         * 

         * @param piter the path iterator of interest

         * @return the length of the path iterator and of the last of its arcs.

         */

        public static double[] getIteratorLengthAndLast(PathIterator piter) {

                double[] resp = new double[2];

                resp[0] = 0;

                resp[1] = 0;

                if (piter == null)

                        return resp;

                double lastx = 0;

                double lasty = 0;

                boolean conn = true;

                float[] current = new float[6];

                // logger.debug("UTILS getIteratorLength. PITER = " + piter);

                while (!piter.isDone()) {

                        if (piter.currentSegment(current) != PathIterator.SEG_MOVETO) {

                                conn = true;

                        } else {

                                conn = false;

                        }

                        resp[1] = distance(lastx, lasty, current[0], current[1]);

                        if (conn)

                                resp[0] = resp[0] + resp[1];

                        lastx = current[0];

                        lasty = current[1];

                        piter.next();

                }

                return resp;

        }

        private void checkLineLength(Feature feature, Curve2D pl, double expected, boolean simpl) {

                int color = 0;

                int eleva = 0;

                if (simpl) {

                        color = (int) Math.round(feature.getDouble("COLOR"));

                        eleva = (int) Math.round(feature.getDouble("ELEVACION"));

                } else {

                        color = feature.getInt("COLOR");

                        eleva = feature.getInt("ELEVACION");

                }

                double len = getIteratorLengthAndLast(pl.getPathIterator(null))[0];

                assertTrue("Not good: " + len  + " and " + expected, acceptablySimilar(expected, len, 0.05));

                switch (color) {

                case 888830465:

                        assertEquals(eleva, -1519669334);

                        break;

                case 135691458:

                        assertEquals(eleva, -1594772521);

                        break;

                case 631009463:

                        assertEquals(eleva, -409958687);

                        break;

                case 601164227:

                        assertEquals(eleva, -1632831996);

                        break;

                case 1766834083:

                        assertEquals(eleva, -671796992);

                        break;

                }

        }

        private void checkMPoint(Feature feature, boolean simpl) {

                int tipocont = 0;

                if (simpl) {

                        tipocont = (int) Math.round(feature.getDouble("TIPOCONT"));

                } else {

                        tipocont = feature.getInt("TIPOCONT");                }                

                tipocont = feature.getInt("TIPOCONT");

                String nomb = feature.getString("FIRST_NOMB").trim();

                MultiPoint2D mp = (MultiPoint2D) feature.getDefaultGeometry(); 

                switch (tipocont) {

                case 116:

                        assertEquals(nomb, "MARIN (EL)");

                        assertTrue("Checking presence of coordinate X: ", oneOfXInMPoint(mp, 272463.83));

                        break;

                case 118:

                        assertEquals(nomb, "SALAMANCA");

                        assertTrue("Checking presence of coordinate X: ", oneOfXInMPoint(mp, 276024.43));

                        break;

                case 15035:

                        assertEquals(nomb, "ORBISO");

                        assertTrue("Checking presence of coordinate X: ", oneOfXInMPoint(mp, 554478.48));

                        break;

                case 19586:

                        assertEquals(nomb, "VALDEZORRAS");

                        assertTrue("Checking presence of coordinate X: ", oneOfXInMPoint(mp, 241343.25));

                        break;

                case 30000:

                         assertEquals(nomb, "ORZOLA");

                         assertTrue("Checking presence of coordinate X: ", oneOfXInMPoint(mp, -619386.36));

                        break;

                }

        }

        private boolean oneOfXInMPoint(Shape pointorpoints, double d) {

                if (pointorpoints instanceof MultiPoint2D) {

                        MultiPoint2D mp = (MultiPoint2D) pointorpoints;

                        int np = mp.getNumPoints();

                        for (int i=0; i<np; i++) {

                                double itemx = mp.getPoint(i).getX();

                                if (acceptablySimilar(d, itemx, 0.01)) return true; 

                        }

                        return false;

                } else {

                        Point2D p = (Point2D) pointorpoints;

                        return acceptablySimilar(d, p.getX(), 0.01); 

                }

        }

        private void checkNullGeometry(Feature feature) {

                Object obj = feature.getDefaultGeometry();

                assertNotNull("Checking not NULL geometry: ", obj);

        }

        private void checkPoint(Feature feature, Point2D point, double expected, boolean simpl) {

                int id = 0;

                if (simpl) {

                        id = (int) Math.round(feature.getDouble("NUMEROENT"));

                } else {

                        id = feature.getInt("NUMEROENT");

                }

                String nomb = feature.getString("NOMBRE").trim();

                assertTrue(acceptablySimilar(expected, point.getX(), 0.01));

                switch (id) {

                case 58:

                        assertEquals(nomb, "MARIN (EL)");

                        break;

                case 59:

                        assertEquals(nomb, "SALAMANCA");

                        break;

                case 2825:

                        assertEquals(nomb, "NAVAHONDILLA");

                        break;

                case 6474:

                        assertEquals(nomb, "CENTENERA");

                        break;

                case 27761:

                        assertEquals(nomb, "EVAN DE ARRIBA");

                        break;

                }

        }

        private boolean acceptablySimilar(double expec, double area, double tol) {

                double diff = Math.abs(expec - area);

                return ((diff / Math.abs((expec + area) / 2)) < tol);

        }

//        public void test_Resources(){

//

//                DataManager manager = DataManager.getManager();

//                Register.selfRegister();

//

//                SHPStoreParameters shpParameters;

//

//                shpParameters=(SHPStoreParameters)manager.createDataStoreParameters(SHPStore.DATASTORE_NAME);

//                shpParameters.setFile(fileNormal);

//

//

//                DataStoreTest.doFileResourceTest(shpParameters);

//        }

        private void initLogger() {

                Date now = new Date(System.currentTimeMillis());

                String nowstr = now.toString();

                nowstr = StringUtil.replaceAllString(nowstr, " ", "_");

                nowstr = StringUtil.replaceAllString(nowstr, ":", "_") + ".txt";

                String outlogpath = "";

                if (Utils.USING_PDA) {

                        outlogpath = ResourceReader.getPdaTestFile(PerformanceTest.SD_FOLDER, "testdata", "basic_test_" + nowstr).getAbsolutePath();

                } else {

                        outlogpath = ResourceReader.getResourceFile("testdata", "basic_test_" + nowstr).getAbsolutePath();

                }

                System.out.println("Log file: " + outlogpath);

                try {

                    PatternLayout l = new PatternLayout("%5p [%t] - %m%n");

                    FileAppender fa = new FileAppender(l, outlogpath, false);

                    // ConsoleAppender ca = new ConsoleAppender(l);

                    Logger.getRootLogger().setLevel(Level.DEBUG);

                    Logger.getRootLogger().addAppender(fa);

                    // Logger.getRootLogger().addAppender(ca);

                } catch (Exception ex) {

                        System.err.println("Error while initializing log4j: " + ex.getMessage());

                }

                logger = Logger.getLogger(SHPTest.class);

        }

}