Application: gvSIG desktop » gvSIG 3D

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

import java.awt.Color;

import java.util.List;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.ISimpleMarkerSymbol;

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

import gov.nasa.worldwind.render.Material;

import gov.nasa.worldwind.render.PointPlacemarkAttributes;

import gov.nasa.worldwind.render.Renderable;

public abstract class AbstractPointRenderableLayer extends RenderableLayer {

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

    protected FeatureStore featureStore;

    protected PointPlacemarkAttributes markAttributes;

    protected VectorLoaderParameters parameters;

    public AbstractPointRenderableLayer(VectorLoaderParameters parameters, FeatureStore featureStore,

        IVectorLegend legend) {

        this.featureStore = featureStore;

        this.parameters = parameters;

        this.markAttributes = getBasicMarkerAttributes(legend);

        ExecutorService executor = Executors.newSingleThreadExecutor();

        executor.execute(addRenderableObjects());

    }

    protected Runnable addRenderableObjects() {

        return 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 = getRenderable(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 PointPlacemarkAttributes getBasicMarkerAttributes(IVectorLegend legend) {

        if (this.markAttributes != null) {

            return this.markAttributes;

        }

        double markerSize = 0;

        Material fillMaterial = null;

        if (legend == null) {

            fillMaterial = new Material(parameters.getDefaultColor());

            markerSize = 0.3;

        } else {

            ISymbol symbol = legend.getDefaultSymbol();

            if (symbol instanceof ISimpleMarkerSymbol) {

                ISimpleMarkerSymbol markerSymbol = (ISimpleMarkerSymbol) symbol;

                Color fillColor = markerSymbol.getColor();

                markerSize = markerSymbol.getSize();

                fillMaterial = new Material(fillColor);

            } else {

                fillMaterial = new Material(parameters.getDefaultColor());

                markerSize = 4;

            }

        }

        markAttributes = new PointPlacemarkAttributes();

        Color color = fillMaterial.getDiffuse();

        markAttributes.setImageColor(color);

        markAttributes.setLineMaterial(fillMaterial);

        markAttributes.setLineWidth(1d);

        markAttributes.setUsePointAsDefaultImage(true);

        markAttributes.setScale(markerSize);

        return markAttributes;

    }

    protected int getAltitudeMode(VectorElevationMode mode) {

        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 abstract List<Renderable> getRenderable(Feature feature);

    protected abstract FeatureQuery getFeatureQuery() throws DataException;

}