Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 Prodevelop S.L  main development

 */

package org.gvsig.geocoding.massive;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import org.gvsig.LayerServer;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.EditableFeature;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.dal.store.dbf.DBFNewStoreParameters;

import org.gvsig.fmap.dal.store.dbf.DBFStoreParameters;

import org.gvsig.fmap.dal.store.dbf.DBFStoreProvider;

import org.gvsig.fmap.dal.store.shp.SHPNewStoreParameters;

import org.gvsig.fmap.dal.store.shp.SHPStoreProvider;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.geocoding.Geocoder;

import org.gvsig.geocoding.GeocodingLocator;

import org.gvsig.geocoding.address.Address;

import org.gvsig.geocoding.address.ComposedAddress;

import org.gvsig.geocoding.address.Literal;

import org.gvsig.geocoding.address.impl.DefaultAddress;

import org.gvsig.geocoding.address.impl.DefaultLiteral;

import org.gvsig.geocoding.impl.DataGeocoderImpl;

import org.gvsig.geocoding.impl.DefaultGeocodingLibrary;

import org.gvsig.geocoding.pattern.GeocodingPattern;

import org.gvsig.geocoding.pattern.GeocodingSource;

import org.gvsig.geocoding.pattern.impl.DefaultGeocodingPattern;

import org.gvsig.geocoding.pattern.impl.DefaultGeocodingSource;

import org.gvsig.geocoding.result.GeocodingResult;

import org.gvsig.geocoding.styles.AbstractGeocodingStyle;

import org.gvsig.geocoding.styles.impl.SimpleCentroid;

import org.gvsig.tools.library.Library;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Test

 * 

 * @author <a href="mailto:jsanz@prodevelop.es"> Jorge Gaspar Sanz Salinas</a>

 * @author <a href="mailto:vsanjaime@prodevelop.es"> Vicent Sanjaime Calvet</a>

 */

public class TestMassiveGeocoding extends

                org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase {

        private static DataManager dataManager = DALLocator.getDataManager();

        private static final Logger log = LoggerFactory

                        .getLogger(TestMassiveGeocoding.class);

        private GeocodingPattern pat = null;

        private List<Set<GeocodingResult>> listResults;

        /**

         * tearDown

         */

        public void tearDown() {

        }

        /**

         * geocoding Massive

         * 

         * @throws DataException

         * @throws CreateGeometryException

         * @throws IOException

         */

        public void testMassive() throws Exception {

                Geocoder geocoder = GeocodingLocator.getInstance().getGeocoder();

                ((DataGeocoderImpl) geocoder).setPattern(pat);

                ((DataGeocoderImpl) geocoder).setStore(LayerServer.getSHPStore(LayerServer.getStreetsFile()));

                // Get addresses

                List<Address> addresses = getAddresses();

                for (Address addr : addresses) {

                        Set<GeocodingResult> results = null;

                        try {

                                results = geocoder.geocode(addr);

                        } catch (Exception e) {

                                log.error("Geocoding", e);

                        }

                        listResults.add(results);

                }

                assertEquals(6, listResults.size());

                // Create DBF file

                FeatureStore allResults = createDBFAllResults();

                // Create Layer select results

                FeatureStore selResults = createGeocodingResultsLayer();

                fillSelectedResultsStore(selResults, allResults);

        }

        /**

         * geocoding Massive

         * 

         * @throws DataException

         * @throws IOException

         */

        private FeatureStore createDBFAllResults() throws DataException,

                        IOException {

                File dbfFile = File.createTempFile("allresults", ".dbf");

                log.debug("Creating temp file at " + dbfFile.getAbsolutePath());

                FeatureStore store = null;

                DataManager manager = DALLocator.getDataManager();

                if (dbfFile != null) {

                        // build DBF store

                        File parentfile = dbfFile.getParentFile();

                        FilesystemServerExplorerParameters exParam = null;

                        try {

                                exParam = (FilesystemServerExplorerParameters) manager

                                                .createServerExplorerParameters(FilesystemServerExplorer.NAME);

                                exParam.setRoot(parentfile.getAbsolutePath());

                                DataServerExplorer serverExplorer = manager

                                                .createServerExplorer(exParam);

                                NewDataStoreParameters newParams = serverExplorer

                                                .getAddParameters(DBFStoreProvider.NAME);

                                ((FilesystemStoreParameters) newParams).setFile(dbfFile);

                                EditableFeatureType featureType = generateFeatureTypeAllResults(

                                                store, listResults.get(0));

                                ((DBFNewStoreParameters) newParams)

                                                .setDefaultFeatureType(featureType);

                                serverExplorer.add(newParams, true);

                                // fill DBF store

                                int max = 10;

                                DBFStoreParameters dbfParameters = (DBFStoreParameters) manager

                                                .createStoreParameters(DBFStoreProvider.NAME);

                                dbfParameters.setFile(dbfFile);

                                store = (FeatureStore) manager.createStore(dbfParameters);

                                store.edit();

                                int id = 0;

                                int idres = 0;

                                Integer[] sels = { 0, 0, 0, 0, 0, 0 };

                                for (Set<GeocodingResult> set : listResults) {

                                        int sel = sels[idres];

                                        int i = 0;

                                        int selec = 0;

                                        for (GeocodingResult res : set) {

                                                if (i >= max) {

                                                        break;

                                                }

                                                EditableFeature feature = store.createNewFeature();

                                                // FIRST fields

                                                feature.setInt("gID", id);

                                                feature.setInt("gID_RESUL", idres);

                                                if (selec == sel) {

                                                        feature.setInt("gSELECT", 1);

                                                } else {

                                                        feature.setInt("gSELECT", 0);

                                                }

                                                feature.setDouble("gSCORE", res.getScore());

                                                Point pto = (Point) res.getGeometry();

                                                feature.setDouble("gX", pto.getX());

                                                feature.setDouble("gY", pto.getY());

                                                // Dynamic address fields

                                                Map<String, String> comps = getMapAddressElements(res

                                                                .getAddress());

                                                for (String key : comps.keySet()) {

                                                        feature.setString(key, comps.get(key));

                                                }

                                                store.insert(feature);

                                                id++;

                                                i++;

                                                selec++;

                                        }

                                        idres++;

                                }

                                store.finishEditing();

                                store.dispose();

                        } catch (Exception e) {

                                log.error("Creating dbf store", e);

                        }

                }

                assertTrue(dbfFile.exists());

                return store;

        }

        /**

         * get pattern

         * 

         * @return

         */

        private GeocodingPattern getPattern() {

                GeocodingPattern pat = new DefaultGeocodingPattern();

                try {

                        pat.setPatternName("SimpleCentroidLines");

                        GeocodingSource source = new DefaultGeocodingSource();

                        source.setLayerName("Streets.shp");

                        source.setLayerProvider("Shape file");

                        AbstractGeocodingStyle style = new SimpleCentroid();

                        Literal relations = new DefaultLiteral();

                        relations.put("Calle", "STREET_NAM");

                        style.setRelationsLiteral(relations);

                        source.setStyle(style);

                        pat.setSource(source);

                } catch (Exception e) {

                        log.error("Building a pattern", e);

                }

                return pat;

        }

        private List<Address> getAddresses() throws Exception {

                List<Address> list = new ArrayList<Address>();

                FeatureStore store = LayerServer.getDBFStore(LayerServer

                                .getStreetsMassiveFile());

                try {

                        FeatureSet features = store.getFeatureSet();

                        for (int i = 0; i < features.getSize(); i++) {

                                list.add(getTableAddress(i));

                        }

                } catch (Exception e) {

                        log.error("", e);

                }

                return list;

        }

        public Address getTableAddress(int row) throws Exception {

                Address address = null;

                FeatureStore store = LayerServer.getDBFStore(LayerServer

                                .getStreetsMassiveFile());

                try {

                        FeatureType type = store.getDefaultFeatureType();

                        FeatureAttributeDescriptor nameDesc = type

                                        .getAttributeDescriptor("tcalle");

                        // Get store from Gmodel and the feature

                        FeatureSet features = null;

                        Feature feature = null;

                        features = store.getFeatureSet();

                        Iterator<Feature> it = features.iterator(row);

                        feature = it.next();

                        // Create the address

                        address = new DefaultAddress();

                        DefaultLiteral literal = new DefaultLiteral();

                        for (int i = 0; i < features.getSize(); i++) {

                                if (row == i) {

                                        String key = "calle";

                                        Object obj = feature.get(nameDesc.getName());

                                        String value = obj.toString();

                                        literal.put(key, value);

                                }

                        }

                        address.setMainLiteral(literal);

                } catch (DataException e) {

                        log.error("Get the feature of FeatureStore", e);

                }

                return address;

        }

        /**

         * Build feature type dbf all results

         * 

         * @return

         * @throws DataException

         */

        private EditableFeatureType generateFeatureTypeAllResults(

                        FeatureStore store, Set<GeocodingResult> result)

                        throws DataException {

                boolean compose = false;

                boolean cross = true;

                // address fields

                Address address = null;

                for (GeocodingResult res : result) {

                        address = res.getAddress();

                        break;

                }

                Literal mainLiteral = address.getMainLiteral();

                int cant = mainLiteral.size();

                Set<String> fields = mainLiteral.keySet();

                int i = 0;

                if (address instanceof ComposedAddress) {

                        compose = true;

                        ComposedAddress caddress = (ComposedAddress) address;

                        List<Literal> inter = caddress.getIntersectionLiterals();

                        if (inter.size() == 2) {

                                cross = false;

                        }

                }

                EditableFeatureType eFType = store.getDefaultFeatureType()

                                .getEditable();

                eFType.add("gID", DataTypes.INT).setSize(10);

                eFType.add("gID_RESUL", DataTypes.INT).setSize(10);

                eFType.add("gSELECT", DataTypes.INT).setSize(10);

                eFType.add("gSCORE", DataTypes.DOUBLE).setSize(10);

                eFType.add("gX", DataTypes.DOUBLE).setSize(14);

                eFType.add("gY", DataTypes.DOUBLE).setSize(14);

                // no compose address

                if (!compose) {

                        for (String field : fields) {

                                eFType.add(field, DataTypes.STRING).setSize(20);

                        }

                }

                // compose address

                else {

                        for (String field : fields) {

                                eFType.add(field + "_1", DataTypes.STRING).setSize(20);

                        }

                        for (String field : fields) {

                                eFType.add(field + "_2", DataTypes.STRING).setSize(20);

                        }

                        // compose between address

                        if (!cross) {

                                for (String field : fields) {

                                        eFType.add(field + "_3", DataTypes.STRING).setSize(20);

                                }

                        }

                }

                return eFType;

        }

        /**

         * get list address elements

         * 

         * @param address

         * @return

         */

        private Map<String, String> getMapAddressElements(Address address) {

                TreeMap<String, String> map = new TreeMap<String, String>();

                Literal lit = address.getMainLiteral();

                for (String mKey : lit.keySet()) {

                        map.put("0_" + mKey, lit.get(mKey));

                }

                if (address instanceof ComposedAddress) {

                        ComposedAddress cAddress = (ComposedAddress) address;

                        List<Literal> interLit = cAddress.getIntersectionLiterals();

                        String iKey;

                        for (int i = 0; i < interLit.size(); i++) {

                                lit = interLit.get(i);

                                for (String mKey : lit.keySet()) {

                                        iKey = Integer.toString(i + 1);

                                        map.put(iKey + "_" + mKey, lit.get(mKey));

                                }

                        }

                }

                return map;

        }

        /**

         * 

         * @param shpFile

         * @return

         */

        private FeatureStore createGeocodingResultsLayer() {

                FeatureStore lyrstore = null;

                File shpFile = new File("c:/geoco/shpresults.shp");

                FLyrVect lyr = null;

                FilesystemServerExplorerParameters explorerParam = null;

                DataManager manager = DALLocator.getDataManager();

                File directory = shpFile.getParentFile();

                try {

                        explorerParam = (FilesystemServerExplorerParameters) manager

                                        .createServerExplorerParameters(FilesystemServerExplorer.NAME);

                        explorerParam.setRoot(directory.getAbsolutePath());

                        DataServerExplorer serverExplorer = manager

                                        .createServerExplorer(explorerParam);

                        SHPNewStoreParameters newShpParams = (SHPNewStoreParameters) serverExplorer

                                        .getAddParameters(SHPStoreProvider.NAME);

                        newShpParams.setSHPFileName(shpFile.getName());

                        newShpParams.setFile(shpFile);

                        EditableFeatureType featureType = generateFeatureTypeSelectedResult(lyrstore);

                        newShpParams.setDefaultFeatureType(featureType);

                        serverExplorer.add(newShpParams, true);

                        lyrstore = (FeatureStore) dataManager.createStore(newShpParams);

                        // LayerFactory factory = LayerFactory.getInstance();

                        // String name = shpFile.getName();

                        // lyr = (FLyrVect) factory.createLayer(name, newShpParams);

                        // lyrstore = lyr.getFeatureStore();

                } catch (Exception e) {

                        log.error("ERROR building FLayer");

                }

                return lyrstore;

        }

        /**

         * Build feature type of the selected results store

         * 

         * @return

         * @throws DataException

         */

        private EditableFeatureType generateFeatureTypeSelectedResult(

                        FeatureStore store) throws DataException {

                EditableFeatureType eFType = store.getDefaultFeatureType()

                                .getEditable();

                eFType.add("gID_RESUL", DataTypes.INT).setSize(10);

                eFType.add("id", DataTypes.STRING).setSize(10);

                eFType.add("gSCORE", DataTypes.DOUBLE).setSize(10);

                eFType.add("gX", DataTypes.DOUBLE).setSize(14);

                eFType.add("gY", DataTypes.DOUBLE).setSize(14);

                // GEOM field

                eFType.add("gGEOMETRY", DataTypes.GEOMETRY).setSize(14);

                eFType.setDefaultGeometryAttributeName("gGEOMETRY");

                return eFType;

        }

        /**

         * Fill selected results store

         * 

         * @param newstore

         * @throws DataException

         * @throws CreateGeometryException

         */

        private void fillSelectedResultsStore(FeatureStore newstore,

                        FeatureStore allResults) throws DataException,

                        CreateGeometryException {

                Integer[] sels = { 0, 0, 0, 0, 0, 0 };

                newstore.edit(FeatureStore.MODE_APPEND);

                int i = 0;

                for (Set<GeocodingResult> set : listResults) {

                        int sel = sels[i];

                        GeocodingResult resu = null;

                        int j = 0;

                        for (GeocodingResult res : set) {

                                if (j == sel) {

                                        resu = res;

                                        break;

                                }

                                j++;

                        }

                        EditableFeature feature = newstore.createNewFeature();

                        String fieldname = "id";

                        // feature.setInt(GeocodingTags.gID, i);

                        if (resu != null) {

                                FeatureSet feats = allResults.getFeatureSet();

                                Iterator<Feature> it = feats.iterator(i);

                                Feature tableFeat = it.next();

                                Object obj = tableFeat.get(fieldname);

                                feature.setInt("gID_RESUL", i);

                                feature.set(fieldname, obj);

                                feature.setDouble("gSCORE", resu.getScore());

                                Point pto = (Point) resu.getGeometry();

                                feature.setDouble("gX", pto.getX());

                                feature.setDouble("gY", pto.getY());

                                GeometryManager geomManager = GeometryLocator

                                                .getGeometryManager();

                                Point geom = (Point) geomManager.createPoint(pto.getX(), pto

                                                .getY(), Geometry.SUBTYPES.GEOM2D);

                                feature.setGeometry("gGEOMETRY", geom);

                        }

                        newstore.insert(feature);

                        i++;

                }

                newstore.finishEditing();

                newstore.dispose();

        }

        @Override

        protected void doSetUp() throws Exception {

                Library geocoLib = new DefaultGeocodingLibrary();

                geocoLib.initialize();

                geocoLib.postInitialize();

                listResults = new ArrayList<Set<GeocodingResult>>();                

                pat = getPattern();

        }

}