Application: gvSIG desktop » gvSIG 3D

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2017 gvSIG Association

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.awt.Color;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.ICoordTrans;

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

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

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

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

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

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

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.symbology.fmap.mapcontext.rendering.symbol.marker.ISimpleMarkerSymbol;

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

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

import gov.nasa.worldwind.render.Path;

import gov.nasa.worldwind.render.PointPlacemark;

import gov.nasa.worldwind.render.PointPlacemarkAttributes;

import gov.nasa.worldwind.render.Renderable;

/**

 * 

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

public class DefaultVectorRenderableLayer extends AbstractRenderableLayer {

    private BasicShapeAttributes polygonShapeAttributes;

    private BasicShapeAttributes lineShapeAttributes;

    private PointPlacemarkAttributes markAttributes;

    public DefaultVectorRenderableLayer(VectorLoaderParameters parameters, FeatureStore featureStore,

        IVectorLegend legend) {

        super(parameters, featureStore, legend);

    }

    @Override

    protected List<Renderable> getRenderables(Feature feature) {

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

                }

            }

        } else if (geom.getGeometryType().isTypeOf(TYPES.POLYGON)) {

            Polygon polygon = (Polygon) geom;

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

                renderables.add(getRenderable(polygon));

            }

        } else if (geom.getGeometryType().isTypeOf(TYPES.MULTIPOINT)) {

            MultiPoint multiPoint = (MultiPoint) geom;

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

                renderables.add(getRenderable(multiPoint.getPointAt(i)));

            }

        } else if (geom.getGeometryType().isTypeOf(TYPES.POINT)) {

            renderables.add(getRenderable((Point) geom));

        } else if (geom.getGeometryType().isTypeOf(TYPES.MULTILINE)) {

            MultiLine multiLine = (MultiLine) geom;

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

                if (multiLine.getCurveAt(i).getNumVertices() >= 2) {

                    renderables.add(getRenderable(multiLine.getCurveAt(i)));

                }

            }

        } else if (geom.getGeometryType().isTypeOf(TYPES.LINE) && ((Line) geom).getNumVertices() >= 2) {

            renderables.add(getRenderable((Line) geom));

        }

        return renderables;

    }

    private gov.nasa.worldwind.render.Polygon getRenderable(Polygon polygon) {

        gov.nasa.worldwind.render.Polygon renderable = new gov.nasa.worldwind.render.Polygon();

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

            }

        }

        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(getPolygonBasicShapeAttributes(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 PointPlacemark getRenderable(Point point) {

        boolean hasZ = point.getDimension() > 2;

        double h = 0.0;

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

        if (coordTrans != null) {

            point.reProject(coordTrans);

        }

        double y = point.getY();

        double x = point.getX();

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

            }

        }

        PointPlacemark marker;

        if (hasZ) {

            double z = point.getCoordinateAt(2);

            marker = new PointPlacemark(Position.fromDegrees(y, x, z + h));

        } else {

            Position position = Position.fromDegrees(y, x, h);

            marker = new PointPlacemark(position);

        }

        marker.setAltitudeMode(getAltitudeMode(parameters.getVectorElevationMode()));

        marker.setAttributes(getBasicMarkerAttributes(super.legend));

        return marker;

    }

    private 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 {

                Color defaultColor = parameters.getDefaultColor();

                if (defaultColor == null) {

                    defaultColor = Color.BLACK;

                }

                fillMaterial = new Material(defaultColor);

                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;

    }

    private BasicShapeAttributes getPolygonBasicShapeAttributes(IVectorLegend legend) {

        if (polygonShapeAttributes != null) {

            return this.polygonShapeAttributes;

        }

        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;

        }

        polygonShapeAttributes = new BasicShapeAttributes();

        polygonShapeAttributes.setInteriorMaterial(fillMaterial);

        polygonShapeAttributes.setInteriorOpacity(fillOpacity);

        polygonShapeAttributes.setOutlineMaterial(outlineMaterial);

        polygonShapeAttributes.setOutlineWidth(outlineWidth);

        return polygonShapeAttributes;

    }

    private Renderable getRenderable(Curve curve) {

        boolean hasZ = curve.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();

            }

        }

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

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

        Path path = new Path(verticesList);

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

        path.setAttributes(getNormalShapAttributes(legend));

        return path;

    }

    private BasicShapeAttributes getNormalShapAttributes(IVectorLegend legend) {

        if (this.lineShapeAttributes != null) {

            return lineShapeAttributes;

        }

        Material outlineMaterial;

        double outlineOpacity = 1.0;

        double outlineWidth = 3.0;

        ISymbol symbol = legend.getDefaultSymbol();

        if (symbol instanceof ILineSymbol) {

            ILineSymbol lineSymbol = (ILineSymbol) symbol;

            Color lineColor = lineSymbol.getColor();

            int lineAlpha = lineSymbol.getAlpha();

            outlineMaterial = new Material(lineColor);

            outlineOpacity = lineAlpha / 255.0;

            outlineWidth = lineSymbol.getLineWidth();

        } else {

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

            outlineOpacity = 1.0;

            outlineWidth = 3.0;

        }

        lineShapeAttributes = new BasicShapeAttributes();

        lineShapeAttributes.setOutlineMaterial(outlineMaterial);

        lineShapeAttributes.setOutlineWidth(outlineWidth);

        lineShapeAttributes.setOutlineOpacity(outlineOpacity);

        return lineShapeAttributes;

    }

    @Override

    protected void clearRenderAttributes() {

        // Sets normal shape attributes to null to force create it again

        this.polygonShapeAttributes = null;

        this.lineShapeAttributes = null;

        this.markAttributes = null;

    }

}