Application: gvSIG desktop » gvSIG 3D

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

import java.awt.Color;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

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

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

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

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

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

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

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

import org.gvsig.view3d.vector.lib.impl.AbstractRenderableLayer;

import gov.nasa.worldwind.geom.Position;

import gov.nasa.worldwind.render.BasicShapeAttributes;

import gov.nasa.worldwind.render.ExtrudedPolygon;

import gov.nasa.worldwind.render.Material;

import gov.nasa.worldwind.render.Renderable;

public class DefaultVectorExtrusionPolygonRenderableLayer extends AbstractRenderableLayer {

    private BasicShapeAttributes normalShapeAttributes;

    private BasicShapeAttributes sideShapeAttributes;

    public DefaultVectorExtrusionPolygonRenderableLayer(VectorLoaderParameters parameters, FeatureStore featureStore,

        IVectorLegend legend) {

        super(parameters, featureStore, legend);

    }

    @Override

    protected List<Renderable> getRenderables(Feature feature) {

        double heightFieldValue = 0;

        String heightField = ((VectorExtrusionLoaderParameters) parameters).getHeightField();

        if (StringUtils.isNoneBlank(heightField)) {

            heightFieldValue = feature.getDouble(heightField);

        }

        Geometry geom = feature.getDefaultGeometry();

        List<Renderable> renderables = new ArrayList<>();

        if (geom.getGeometryType().isTypeOf(TYPES.MULTIPOLYGON)) {

            MultiPolygon multiPolygon = (MultiPolygon) geom;

            for (int i = 0; i < multiPolygon.getPrimitivesNumber(); i++) {

                Polygon polygon = (Polygon) multiPolygon.getSurfaceAt(i);

                if (polygon.getNumVertices() >= 4) {

                    renderables.add(getRenderable(polygon, heightFieldValue));

                }

            }

        } else {

            Polygon polygon = (Polygon) geom;

            if (polygon.getNumVertices() >= 4) {

                renderables.add(getRenderable(polygon, heightFieldValue));

            }

        }

        return renderables;

    }

    @Override

    protected FeatureQuery getFeatureQuery() throws DataException {

        FeatureQuery featureQuery = super.getFeatureQuery();

        // Add field height to feature query

        String fieldHeight = ((VectorExtrusionLoaderParameters) parameters).getHeightField();

        if (StringUtils.isNotBlank(fieldHeight)) {

            featureQuery.addAttributeName(fieldHeight);

        }

        return featureQuery;

    }

    private ExtrudedPolygon getRenderable(Polygon polygon, double heightFieldValue) {

        ExtrudedPolygon renderable = new ExtrudedPolygon();

        boolean hasZ = polygon.getDimension() > 2;

        double h = 0.0;

        if (VectorElevationMode.CLAMP_TO_GROUND.equals(parameters.getVectorElevationMode())) {

            hasZ = false;

        } else {

            if (VectorElevationMode.RELATIVE_TO_GROUND.equals(parameters.getVectorElevationMode())) {

                hasZ = false;

            }

            if (parameters.getConstantHeight() != null) {

                h = parameters.getConstantHeight();

            }

        }

        h += heightFieldValue;

        h *= ((VectorExtrusionLoaderParameters) parameters).getVerticalExaggeration();

        ICoordTrans coordTrans = getCoordTrans(this.parameters.getLayer().getProjection());

        List<Position> verticesList = getVertices(polygon, h, hasZ, coordTrans);

        renderable.setOuterBoundary(verticesList);

        int numInteriorRings = polygon.getNumInteriorRings();

        for (int i = 0; i < numInteriorRings; i++) {

            renderable.addInnerBoundary(getInteriorRing(polygon.getInteriorRing(i), hasZ, h));

        }

        renderable.setAltitudeMode(getAltitudeMode(this.parameters.getVectorElevationMode()));

        renderable.setAttributes(getNormalShapeAttributes(legend));

        renderable.setSideAttributes(getSideShapeAttributes(legend));

        return renderable;

    }

    private List<Position> getInteriorRing(Ring interiorRing, boolean hasZ, double h) {

        int internalNumVertices = interiorRing.getNumVertices();

        List<Position> internalVerticesList = new ArrayList<>(internalNumVertices);

        for (int j = 0; j < internalNumVertices; j++) {

            Point vertex = interiorRing.getVertex(j);

            if (hasZ) {

                double z = vertex.getCoordinateAt(2);

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

            } else {

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

            }

        }

        return internalVerticesList;

    }

    private BasicShapeAttributes getSideShapeAttributes(IVectorLegend legend) {

        if(this.sideShapeAttributes != null) {

            return this.sideShapeAttributes;

        }

        Material sideFillMaterial = Material.GRAY;

        double fillOpacity = 0.7;

        ISymbol symbol = legend.getDefaultSymbol();

        if (symbol instanceof IFillSymbol) {

            IFillSymbol fillSymbol = (IFillSymbol) symbol;

            Color fillColor = fillSymbol.getFillColor();

            int fillAlpha = fillSymbol.getFillAlpha();

            Color sideFillColor = darkenColor(fillColor);

            sideFillMaterial = new Material(sideFillColor);

            fillOpacity = fillAlpha / 255.0;

        } else {

            sideFillMaterial = new Material(this.parameters.getDefaultColor());

            fillOpacity = 0.7;

        }

        sideShapeAttributes = new BasicShapeAttributes();

        sideShapeAttributes.setInteriorMaterial(sideFillMaterial);

        sideShapeAttributes.setInteriorOpacity(fillOpacity);

        return sideShapeAttributes;

    }

    private BasicShapeAttributes getNormalShapeAttributes(IVectorLegend legend) {

        if(this.normalShapeAttributes != null) {

            return this.normalShapeAttributes;

        }

        Material fillMaterial = Material.LIGHT_GRAY;

        Material outlineMaterial = Material.BLACK;

        double fillOpacity = 0.7;

        double outlineWidth = 2;

        ISymbol symbol = legend.getDefaultSymbol();

        if (symbol instanceof IFillSymbol) {

            IFillSymbol fillSymbol = (IFillSymbol) symbol;

            Color fillColor = fillSymbol.getFillColor();

            int fillAlpha = fillSymbol.getFillAlpha();

            ILineSymbol outline = fillSymbol.getOutline();

            Color lineColor = outline.getColor();

            fillMaterial = new Material(fillColor);

            outlineMaterial = new Material(lineColor);

            fillOpacity = fillAlpha / 255.0;

            outlineWidth = outline.getLineWidth();

        } else {

            outlineMaterial = new Material(this.parameters.getDefaultColor());

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

            fillOpacity = 0.7;

            outlineWidth = 2;

        }

        normalShapeAttributes = new BasicShapeAttributes();

        normalShapeAttributes.setInteriorMaterial(fillMaterial);

        normalShapeAttributes.setInteriorOpacity(fillOpacity);

        normalShapeAttributes.setOutlineMaterial(outlineMaterial);

        normalShapeAttributes.setOutlineWidth(outlineWidth);

        return normalShapeAttributes;

    }

    /**

     * Slightly darken the supplied color.

     * 

     * @param color

     *            the color to make darker.

     * @return the darker color.

     */

    private Color darkenColor(Color color) {

        float factor = 0.8f;

        int r = color.getRed();

        int g = color.getGreen();

        int b = color.getBlue();

        return new Color(Math.max((int) (r * factor), 0), Math.max((int) (g * factor), 0),

            Math.max((int) (b * factor), 0));

    }

    @Override

    protected void clearRenderAttributes() {

        this.normalShapeAttributes = null;

        this.sideShapeAttributes = null;

    }

}