Application: gvSIG desktop » gvSIG 3D

package org.gvsig.view3d.vector.lib.impl;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.crs.CRSFactory;

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

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

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

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.view3d.vector.lib.api.VectorElevationMode;

import org.gvsig.view3d.vector.lib.api.VectorLoaderParameters;

import gov.nasa.worldwind.WorldWind;

import gov.nasa.worldwind.geom.Position;

import gov.nasa.worldwind.layers.RenderableLayer;

import gov.nasa.worldwind.render.Renderable;

public abstract class AbstractRenderableLayer extends RenderableLayer {

    private static final Logger LOG = LoggerFactory.getLogger(AbstractRenderableLayer.class);

    protected FeatureStore featureStore;

    protected IVectorLegend legend;

    protected VectorLoaderParameters parameters;

    public AbstractRenderableLayer(VectorLoaderParameters parameters, FeatureStore featureStore, IVectorLegend legend) {

        this.featureStore = featureStore;

        this.legend = legend;

        this.parameters = parameters;

        addRenderableObjects();

    }

    protected void addRenderableObjects() {

        ExecutorService executor = Executors.newSingleThreadExecutor();

        executor.execute( new Runnable() {

            @Override

            public void run() {

                FeatureQuery featureQuery;

                try {

                    featureQuery = getFeatureQuery();

                } catch (DataException e) {

                    LOG.error(String.format("Can not access to feature type of %1s", featureStore.getFullName()), e);

                    removeAllRenderables();

                    return;

                }

                FeatureSet featureSet = null;

                DisposableIterator it = null;

                try {

                    featureSet = featureStore.getFeatureSet(featureQuery);

                    it = featureSet.fastIterator();

                    while (it.hasNext()) {

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

                        List<Renderable> renderables = getRenderables(feature);

                        for (Renderable renderable : renderables) {

                            addRenderable(renderable);

                        }

                    }

                } catch (DataException e) {

                    LOG.error(String.format("Can not access to %1s data", featureStore.getFullName()), e);

                    removeAllRenderables();

                    return;

                } finally {

                    if (it != null) {

                        it.dispose();

                    }

                    if (featureSet != null) {

                        featureSet.dispose();

                    }

                }

            }

        });

    }

    protected int getAltitudeMode(VectorElevationMode mode) {

        if(mode == null) {

            LOG.debug("Setting clamp to ground altitude mode by default");

            return WorldWind.CLAMP_TO_GROUND;

        }

        switch (mode) {

        case CLAMP_TO_GROUND:

            return WorldWind.CLAMP_TO_GROUND;

        case ABSOLUTE:

            return WorldWind.ABSOLUTE;

        case RELATIVE_TO_GROUND:

            return WorldWind.RELATIVE_TO_GROUND;

        default:

            throw new IllegalArgumentException(

                "Vector elevation mode not reconized. Only CLAMP_TO_GROUND, ABSOLUTE and RELATIVE_TO_GROUND are valid");

        }

    }

    protected FeatureQuery getFeatureQuery() throws DataException {

        FeatureType featureType = featureStore.getDefaultFeatureType();

        String geomAtt = featureType.getDefaultGeometryAttributeName();

        FeatureQuery featureQuery = featureStore.createFeatureQuery();

        featureQuery.addAttributeName(geomAtt);

        return featureQuery;

    }

    protected List<Position> getVertices(OrientablePrimitive primitive, double h, boolean hasZ, ICoordTrans coordTrans) {

        List<Position> verticesList = new ArrayList<>(primitive.getNumVertices());

        for (int i = 0; i < primitive.getNumVertices(); i++) {

            Point vertex = primitive.getVertex(i);

            // Reproject point if there is a coordinate transformation

            if (coordTrans != null) {

                vertex.reProject(coordTrans);

            }

            if (hasZ) {

                double z = vertex.getCoordinateAt(2);

                verticesList.add(Position.fromDegrees(vertex.getY(), vertex.getX(), z + h));

            } else {

                verticesList.add(Position.fromDegrees(vertex.getY(), vertex.getX(), h));

            }

        }

        return verticesList;

    }

    protected ICoordTrans getCoordTrans(IProjection origProj) {

        IProjection destProj = CRSFactory.getCRS("EPSG:4326");

        return origProj.getCT(destProj);

    }

    @Override

    public void setExpiryTime(long expiryTime) {

        // If expiry time is greater than last expiry time, reload

        // renderables

        if (expiryTime > this.getExpiryTime()) {

            reloadRenderables();

        }

        super.setExpiryTime(expiryTime);

    }

    protected void reloadRenderables() {

        // Clear renderables

        clearRenderables();

        // Clear render attibutes

        clearRenderAttributes();

        // Reload renderables

        addRenderableObjects();

    }

    /**

     *

     */

    protected abstract void clearRenderAttributes();

    /**

     *

     * @param feature

     * @return

     */

    protected abstract List<Renderable> getRenderables(Feature feature);

}