Application: gvSIG desktop » gvSIG 3D

/* 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.gvsig3d.osg.io;

import java.io.File;

import java.util.ArrayList;

import java.util.Vector;

import javax.swing.JOptionPane;

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.FileHelper;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider;

import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;

import org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider;

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.exception.ResourceNotifyCloseException;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

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

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

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException;

import org.gvsig.fmap.geom.type.GeometryTypeNotValidException;

import org.gvsig.osgvp.core.osg.Group;

import org.gvsig.osgvp.core.osg.Node;

import org.gvsig.osgvp.core.osg.Vec3;

import org.gvsig.osgvp.core.osgdb.osgDB;

import org.gvsig.osgvp.exceptions.node.ChildIndexOutOfBoundsExceptions;

import org.gvsig.osgvp.exceptions.node.LoadNodeException;

import org.gvsig.osgvp.exceptions.node.NodeException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Data provider for OSG files with raster data

 * 

 * @author Rafael Gait?n (rafa.gaitan@mirage-tech.com)

 */

public class OSGStoreProvider extends AbstractMemoryStoreProvider implements

                ResourceConsumer {

        private static final Logger logger = LoggerFactory

                        .getLogger(OSGStoreProvider.class);

        public static final String NAME = "OSG";

        public static final String DESCRIPTION = "OSG file";

        public static final String METADATA_DEFINITION_NAME = NAME;

        private ResourceProvider resource;

        private SimpleTaskStatus taskStatus;

        private Node _osgNode;

        private long counterNewsOIDs = 0;

        private Envelope envelope;

        private int counterFeatures = 0;

        // An OSG store has one row with id, a point (center of bounding box) and

        // the entity (the filename)

        public static final String NAME_FIELD_ID = "ID";

        public static final String NAME_FIELD_GEOMETRY = "Geometry";

        // public static final String NAME_FIELD_ENTITY = "Entity";

        private int ID_FIELD_ID = 0;

        private int ID_FIELD_GEOMETRY = 1;

        private EditableFeatureType featureType;

        // private int ID_FIELD_ENTITY = 2;

        public OSGStoreProvider(OSGStoreParameters parameters,

                        DataStoreProviderServices storeServices) throws InitializeException {

                super(parameters, storeServices, FileHelper

                                .newMetadataContainer(METADATA_DEFINITION_NAME));

                TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

                this.taskStatus = manager.createDefaultSimpleTaskStatus("OSG");

                File file = getOSGParameters().getFile();

                resource = this.createResource(FileResource.NAME,

                                new Object[] { file.getAbsolutePath() });

                counterNewsOIDs = 0;

                resource.addConsumer(this);

                this.initializeFeatureTypes();

        }

        protected void initializeFeatureTypes() throws InitializeException {

                try {

                        this.open();

                } catch (OpenException e) {

                        throw new InitializeException(this.getProviderName(), e);

                }

        }

        public boolean closeResourceRequested(ResourceProvider arg0) {

                // TODO Auto-generated method stub

                return false;

        }

        public void resourceChanged(ResourceProvider arg0) {

                // TODO Auto-generated method stub

        }

        public Object createNewOID() {

                return new Long(counterNewsOIDs++);

        }

        public int getOIDType() {

                return DataTypes.LONG;

        }

        public String getFullName() {

                return this.getOSGParameters().getFile().getAbsolutePath();

        }

        public String getName() {

                String name = this.getOSGParameters().getFile().getName();

                int n = name.lastIndexOf(".");

                if (n < 1) {

                        return name;

                }

                return name.substring(0, n);

        }

        private OSGStoreParameters getOSGParameters() {

                return (OSGStoreParameters) this.getParameters();

        }

        public String getProviderName() {

                return NAME;

        }

        public ResourceProvider getResource() {

                return resource;

        }

        public Object getSourceId() {

                return this.getOSGParameters().getFile();

        }

        public DataServerExplorer getExplorer() throws ReadException {

                DataManager manager = DALLocator.getDataManager();

                FilesystemServerExplorerParameters params;

                try {

                        params = (FilesystemServerExplorerParameters) manager

                                        .createServerExplorerParameters(FilesystemServerExplorer.NAME);

                        params.setRoot(this.getOSGParameters().getFile().getParent());

                        return manager.openServerExplorer(FilesystemServerExplorer.NAME,

                                        params);

                } catch (DataException e) {

                        throw new ReadException(this.getProviderName(), e);

                } catch (ValidateDataParametersException e) {

                        throw new ReadException(this.getProviderName(), e);

                }

        }

        public void open() throws OpenException {

                if (_osgNode != null) {

                        return;

                }

                try {

                        this.taskStatus.add();

                        getResource().execute(new ResourceAction() {

                                public Object run() throws Exception {

                                        resource.notifyOpen();

                                        File f = new File(getFullName());

                                        if (f.exists()) {

                                                try {

                                                        Node loadedNode = osgDB.readNodeFile(getFullName());

                                                        if (loadedNode == null) {

                                                                JOptionPane.showMessageDialog(null,

                                                                                "Can't open the file");

                                                                return null;

                                                        }

                                                        // Open existing gvSIG3D layer

                                                        if (loadedNode.getNodeName().equals("gvSIG3D")) {

                                                                processLayerGvSIG(loadedNode);

                                                                configureFeatures();

                                                                addFeatures();

                                                        }

                                                        // Open non gvSIG3D layer

                                                        else {

                                                                processLayerNoGvSIG(loadedNode);

                                                                configureFeatures();

                                                                addFeatures();

                                                        }

                                                } catch (LoadNodeException e) {

                                                        logger.error("Cannot load "

                                                                        + getFullName()

                                                                        + ", please check osg plugins and library paths");

                                                        return null;

                                                }

                                                // Create a new gvSIG3D layer

                                        } else {

                                                processNewLayerGvSIG();

                                                configureFeatures();

                                                addFeatures();

                                        }

                                        return null;

                                }

                        });

                        this.taskStatus.terminate();

                } catch (Exception e) {

                        _osgNode = null;

                        this.taskStatus.abort();

                        try {

                                throw new OpenException(resource.getName(), e);

                        } catch (AccessResourceException e1) {

                                throw new OpenException(getProviderName(), e);

                        }

                } finally {

                        this.taskStatus.remove();

                }

        }

        protected void configureFeatures() throws ResourceNotifyCloseException,

                        GeometryTypeNotSupportedException, GeometryTypeNotValidException {

                FeatureStoreProviderServices store = getStoreServices();

                data = new ArrayList(); // this must be initialized

                resource.notifyClose();

                GeometryManager manager = GeometryLocator.getGeometryManager();

                featureType = store.createFeatureType();

                featureType.setHasOID(true);

                ID_FIELD_ID = featureType.add(NAME_FIELD_ID, DataTypes.INT)

                                .setDefaultValue(Integer.valueOf(0)).getIndex();

                EditableFeatureAttributeDescriptor attr = featureType.add(

                                NAME_FIELD_GEOMETRY, DataTypes.GEOMETRY);

                // attr.setSRS(getOSGParameters().getCRS()); // say what?

                GeometryType geomType = manager.getGeometryType(TYPES.POINT,

                                SUBTYPES.GEOM3D);

                attr.setGeometryType(geomType.getType());

                ID_FIELD_GEOMETRY = attr.getIndex();

                featureType.setDefaultGeometryAttributeName(NAME_FIELD_GEOMETRY);

                // ID_FIELD_ENTITY = featureType

                // .add(NAME_FIELD_ENTITY, DataTypes.STRING, 1024)

                // .setDefaultValue("").getIndex();

                // only one type and also the default type so :)

                ArrayList<EditableFeatureType> types = new ArrayList<EditableFeatureType>();

                types.add(featureType);

                store.setFeatureTypes(types, featureType);

                // Ok we have configured the "table" so now let's fill it

                // with values

        }

        protected void addFeatures() {

                Group parent;

                // Create a new group if the scene has been loaded as a node

                if (!(_osgNode instanceof Group))

                        try {

                                parent = new Group(_osgNode.getCPtr());

                        } catch (NodeException e) {

                                return;

                        }

                else

                        parent = (Group) _osgNode;

                if (parent.getNumChildren() == 0) {

                        // Vector<Vec3> bound = new Vector<Vec3>();

                        // bound.add(new Vec3(-1.0, -1.0, -1.0));

                        // bound.add(new Vec3(1.0, 1.0, 1.0));

                        // addOneFeature(bound);

                        GeometryManager manager = GeometryLocator.getGeometryManager();

                        if (envelope == null)

                                try {

                                        Point min = manager.createPoint(-1.0, -1.0, SUBTYPES.GEOM3D);

                                        min.setCoordinateAt(2, 0.0);

                                        Point max = manager.createPoint(1.0, 1.0, SUBTYPES.GEOM3D);

                                        max.setCoordinateAt(2, 0.0);

                                        envelope = manager.createEnvelope(SUBTYPES.GEOM3D);

                                        envelope.setLowerCorner(min);

                                        envelope.setUpperCorner(max);

                                } catch (CreateEnvelopeException e) {

                                        // TODO Auto-generated catch block

                                        e.printStackTrace();

                                } catch (CreateGeometryException e) {

                                        // TODO Auto-generated catch block

                                        e.printStackTrace();

                                }

                }

                for (int i = 0; i < parent.getNumChildren(); i++) {

                        try {

                                Vector<Vec3> bound = parent.getChild(i).getBoundingBox();

                                addOneFeature(bound);

                        } catch (ChildIndexOutOfBoundsExceptions e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                }

        }

        protected void addOneFeature(Vector<Vec3> bound) {

                GeometryManager manager = GeometryLocator.getGeometryManager();

                FeatureProvider fProvider = new DefaultFeatureProvider(

                                featureType.getNotEditableCopy());

                fProvider.set(ID_FIELD_ID, Integer.valueOf(counterFeatures));

                counterFeatures++;

                Point min;

                try {

                        min = manager.createPoint(bound.get(0).x(), bound.get(0).y(),

                                        SUBTYPES.GEOM3D);

                        min.setCoordinateAt(2, bound.get(0).z());

                        Point max = manager.createPoint(bound.get(1).x(), bound.get(1).y(),

                                        SUBTYPES.GEOM3D);

                        max.setCoordinateAt(2, bound.get(1).z());

                        if (envelope == null)

                                envelope = manager.createEnvelope(SUBTYPES.GEOM3D);

                        Envelope featureEnvelope = manager.createEnvelope(SUBTYPES.GEOM3D);

                        featureEnvelope.setLowerCorner(min);

                        featureEnvelope.setUpperCorner(max);

                        double centerx = featureEnvelope.getCenter(0);

                        double centery = featureEnvelope.getCenter(1);

                        double centerz = featureEnvelope.getCenter(2);

                        Point geom = manager.createPoint(centerx, centery, SUBTYPES.GEOM3D);

                        geom.setCoordinateAt(2, centerz);

                        fProvider.set(ID_FIELD_GEOMETRY, geom);

                        envelope.add(featureEnvelope);

                        // fProvider.getDefaultEnvelope().add(envelope);

                        // fProvider.setDefaultEnvelope(envelope);

                        fProvider.setDefaultGeometry(geom);

                        addFeatureProvider(fProvider);

                } catch (CreateGeometryException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (CreateEnvelopeException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        protected void processNewLayerGvSIG() {

                _osgNode = new Group();

                _osgNode.setNodeName("gvSIG3D");

        }

        protected void processLayerNoGvSIG(Node node) {

                _osgNode = new Group();

                _osgNode.setNodeName("gvSIG3D");

                try {

                        ((Group) _osgNode).addChild(node);

                } catch (NodeException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        protected void processLayerGvSIG(Node node) {

                _osgNode = node;

        }

        public Object getNode() throws OpenException {

                this.open();

                if (_osgNode == null) {

                        return null;

                }

                return _osgNode;

        }

        public Envelope getEnvelope() throws DataException {

                this.open();

                return this.envelope;

        }

}