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 org.gvsig.fmap.dal.DataStoreNotification;

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.impl.DefaultEditableFeatureType;

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.file.FileResource;

import org.gvsig.fmap.dal.resource.impl.DefaultResourceNotification;

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

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

        // 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 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();

                                        FeatureStoreProviderServices store = getStoreServices();

                                        File f = new File(getFullName());

                                        Vector<Vec3> bound;

                                        if (f.exists()) {

                                                try {

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

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

                                                                _osgNode = loadedNode;

                                                                Vector<Vec3> bb = _osgNode.getBoundingBox();

                                                                Group emptyGroup = new Group();

                                                                Vector<Vec3> emptyBB = emptyGroup.getBoundingBox();

                                                                if (bb.equals(emptyBB)) {

                                                                        bound = new Vector<Vec3>();

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

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

                                                                }

                                                                else 

                                                                        bound = _osgNode.getBoundingBox();

                                                        }

                                                        else {

                                                                _osgNode = new Group();

                                                                _osgNode.setNodeName("gvSIG3D");

                                                                ((Group) _osgNode).addChild(loadedNode);

                                                                bound = _osgNode.getBoundingBox();

                                                        }

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

                                                                                                        // ???

                                                } catch (LoadNodeException e) {

                                                        logger.error("Cannot load "

                                                                        + getFullName()

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

                                                        return null;

                                                }

                                                catch (NodeException e) {

                                                        // TODO Auto-generated catch block

                                                        e.printStackTrace();

                                                        return null;

                                                }

                                                // In case the file doesn't exist, we create it. Needed

                                                // to create the new OSG

                                                // layers for the edition tools

                                        } else {

                                                _osgNode = new Group();

                                                _osgNode.setNodeName("gvSIG3D");

                                                bound = new Vector<Vec3>();

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

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

                                                data = new ArrayList();

                                        }

                                        resource.notifyClose();

                                        GeometryManager manager = GeometryLocator

                                                        .getGeometryManager();

                                        EditableFeatureType 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

                                        FeatureProvider fProvider = new DefaultFeatureProvider(

                                                        featureType.getNotEditableCopy());

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

                                        // feature.set(ID_FIELD_ENTITY, getFullName());

                                        Point 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());

                                        envelope = manager.createEnvelope(SUBTYPES.GEOM3D);

                                        envelope.setLowerCorner(min);

                                        envelope.setUpperCorner(max);

                                        double centerx = envelope.getCenter(0);

                                        double centery = envelope.getCenter(1);

                                        double centerz = envelope.getCenter(2);

                                        Point geom = manager.createPoint(centerx, centery,

                                                        SUBTYPES.GEOM3D);

                                        geom.setCoordinateAt(2, centerz);

                                        fProvider.set(ID_FIELD_GEOMETRY, geom);

                                        fProvider.setDefaultEnvelope(envelope);

                                        fProvider.setDefaultGeometry(geom);

                                        addFeatureProvider(fProvider);

                                        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();

                }

        }

        public Object getNode() throws OpenException {

                this.open();

                if (_osgNode == null) {

                        return null;

                }

                return _osgNode;

        }

        public Envelope getEnvelope() throws DataException {

                this.open();

                return this.envelope;

        }

}