Application: gvSIG desktop » gvSIG raster

/* 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.

*

*/

package org.gvsig.raster.impl.grid.roi;

import java.awt.Color;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import org.cresques.cts.IProjection;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.coverage.exception.FileNotExistsException;

import org.gvsig.fmap.dal.coverage.exception.ROIException;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

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

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

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

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

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

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.store.shp.SHPStoreParameters;

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

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.fmap.geom.primitive.NullGeometry;

import org.gvsig.raster.roi.ROI;

import org.gvsig.raster.roi.ROIReader;

import org.gvsig.tools.dispose.DisposableIterator;

public class VectorialROIsReader implements ROIReader {

        private HashMap<String, ROI>   rois         = null;

        private RasterDataStore        store        = null;

        private Envelope               bbox         = null;

        private FeatureStore[]         featureStore = null;

        public VectorialROIsReader(

                        FeatureStore featureStore,

                        RasterDataStore store,

                        IProjection projection) {

                Rectangle2D e = store.getExtent().toRectangle2D();

                try {

                        bbox = GeometryLocator.getGeometryManager().createEnvelope(

                                        e.getX(), e.getY(), e.getMaxX(), e.getMaxY(), SUBTYPES.GEOM2D);

                } catch (CreateEnvelopeException e1) {

                        LoggerFactory.getLogger(VectorialROIsReader.class).error("Error creating the envelope", e);

                }

                this.store = store;

                this.featureStore = new FeatureStore[1];

                this.featureStore[0] = featureStore;

        }

        /**

         * Constructor using the envelope of the raster layer

         * @param filename

         * @param store

         * @param projection

         * @throws InvalidROIsShpException

         * @throws FileNotExistsException

         */

        public VectorialROIsReader(

                        String filename,

                        RasterDataStore store,

                        IProjection projection) throws ROIException, FileNotExistsException {

                Rectangle2D e = store.getExtent().toRectangle2D();

                try {

                        Envelope env = GeometryLocator.getGeometryManager().createEnvelope(

                                        e.getX(), e.getY(), e.getMaxX(), e.getMaxY(), SUBTYPES.GEOM2D);

                        init(filename, store, projection, env);

                } catch (CreateEnvelopeException e1) {

                        LoggerFactory.getLogger(VectorialROIsReader.class).error("Error creating the envelope", e);

                }

        }

        public VectorialROIsReader(

                        String filename,

                        RasterDataStore store,

                        IProjection projection,

                        Envelope bbox) throws ROIException, FileNotExistsException {

                init(filename, store, projection, bbox);

        }

        public void init(

                        String filename,

                        RasterDataStore store,

                        IProjection projection,

                        Envelope bbox) throws ROIException, FileNotExistsException {

                this.store = store;

                this.bbox = bbox;

                File file = new File(filename);

                if(file.exists()) {

                        this.featureStore = new FeatureStore[1];

                        this.featureStore[0] = openOneROIFile(file, projection);

                } else {

                        file = new File(filename + ".shp");

                        if(file.exists()) {

                                this.featureStore = new FeatureStore[1];

                                this.featureStore[0] = openOneROIFile(file, projection);

                        } else {

                                this.featureStore = openThreeROIFiles(filename, projection);

                        }

                }

        }

        private FeatureStore[] openThreeROIFiles(String filename, IProjection projection) throws ROIException, FileNotExistsException {

                FeatureStore[] featureStore = new FeatureStore[3];

                if(filename.endsWith(".shp")) {

                        filename = filename.substring(0, filename.lastIndexOf(".shp"));

                }

                File file = new File(filename + "_polygons.shp");

                boolean existsAtLeastOne = false;

                if(file.exists()) {

                        featureStore[0] = openOneROIFile(file, projection);

                        existsAtLeastOne = true;

                }

                file = new File(filename + "_points.shp");

                if(file.exists()) {

                        featureStore[1] = openOneROIFile(file, projection);

                        existsAtLeastOne = true;

                }

                file = new File(filename + "_polylines.shp");

                if(file.exists()) {

                        featureStore[2] = openOneROIFile(file, projection);

                        existsAtLeastOne = true;

                }

                if(!existsAtLeastOne)

                        throw new FileNotExistsException("file not found");

                return featureStore;

        }

        private FeatureStore openOneROIFile(File file, IProjection projection) throws ROIException {

                DataManager datamanager = DALLocator.getDataManager();

                SHPStoreParameters params = null;

                try {

                        params = (SHPStoreParameters)datamanager.createStoreParameters(SHPStoreProvider.NAME);

                        params.setCRS(projection);

                } catch (InitializeException e) {

                        throw new ROIException(e.getMessage(), e);

                } catch (ProviderNotRegisteredException e) {

                        throw new ROIException(e.getMessage(), e);

                }

                params.setFile(file);

                DataManager dataManager = DALLocator.getDataManager();

                try {

                        return (FeatureStore)dataManager.openStore(params.getDataStoreName(), params);

                } catch (ValidateDataParametersException e) {

                        throw new ROIException(e.getMessage(), e);

                } catch (InitializeException e) {

                        throw new ROIException(e.getMessage(), e);

                } catch (ProviderNotRegisteredException e) {

                        throw new ROIException(e.getMessage(), e);

                }

        }

        public List<ROI> read(List<ROI> existingROIs) throws ROIException {

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

                        try {

                                existingROIs = read(existingROIs, this.featureStore[i]);

                        } catch (InvalidROIsShpException e) {

                                throw new ROIException("", e);

                        } catch (DataException e) {

                                throw new ROIException("", e);

                        }

                }

                return existingROIs;

        }

        @SuppressWarnings("deprecation")

        public List<ROI> read(List<ROI> existingROIs, FeatureStore featureStore) throws InvalidROIsShpException, DataException {

                FeatureType featureType = featureStore.getDefaultFeatureType();

                long id = System.currentTimeMillis();

                int nameFieldIndex = featureType.getIndex("name");

                int rFiledIndex = featureType.getIndex("R");

                int gFiledIndex = featureType.getIndex("G");

                int bFiledIndex = featureType.getIndex("B");

                if (existingROIs != null) {

                        rois = new HashMap<String, ROI>();

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

                                VectorialROIImpl roi = (VectorialROIImpl)existingROIs.get(i);

                                rois.put(roi.getName(), roi);

                        }

                }

                String roiName;

                int r = 255, g = 0, b = 0;

                FeatureSet set = null;

                DisposableIterator features = null;

                try {

                        set = featureStore.getFeatureSet();

                        features = set.fastIterator();

                        String defaultROIName = "ROI";

                        while (features.hasNext()) {

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

                                if(feature.getDefaultGeometry() == null ||

                                   feature.getDefaultGeometry() instanceof NullGeometry)

                                        continue;

                                if(feature.getDefaultGeometry() != null &&

                                   !feature.getDefaultGeometry().getEnvelope().intersects(bbox))

                                        continue;

                                if(nameFieldIndex >= 0)

                                        roiName = feature.getString(nameFieldIndex).toString();

                                else {

                                        roiName = defaultROIName + "-" + (id++);

                                }

                                VectorialROIImpl roi = null;

                                if (!rois.containsKey(roiName)) {

                                        roi = new VectorialROIImpl(store);

                                        roi.setName(roiName);

                                        if(rFiledIndex >= 0)

                                                r = ((Number) feature.get(rFiledIndex)).intValue();

                                        if(gFiledIndex >= 0)

                                                g = ((Number) feature.get(gFiledIndex)).intValue();

                                        if(bFiledIndex >= 0)

                                                b = ((Number) feature.get(bFiledIndex)).intValue();

                                        roi.setColor(new Color(r, g, b));

                                        rois.put(roi.getName(), roi);

                                } else

                                        roi = (VectorialROIImpl) rois.get(roiName);

                                roi.addGeometry(feature.getDefaultGeometry());

                        }

                } finally {

                        if (features != null)

                                features.dispose();

                        if (set != null)

                                set.dispose();

                }

                return new ArrayList<ROI>(rois.values());

        }

}