Application: gvSIG desktop » gvSIG 3D

package org.gvsig.gvsig3d.cacheservices;

import java.awt.BasicStroke;

import java.awt.Color;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.List;

import java.util.Vector;

import org.apache.log4j.Logger;

import org.cresques.cts.IProjection;

import org.cresques.px.Extent;

import org.gvsig.cacheservice.CacheService;

import org.gvsig.gvsig3d.gui.FeatureFactory;

import org.gvsig.gvsig3d.labels3D.ILabel3D;

import org.gvsig.gvsig3d.labels3D.SimpleLabel3D;

import org.gvsig.gvsig3d.simbology3D.Line3DFeature;

import org.gvsig.gvsig3d.simbology3D.Point3DFeature;

import org.gvsig.gvsig3d.simbology3D.Polygon3DFeature;

import org.gvsig.gvsig3d.simbology3D.Symbology3DFactory;

import org.gvsig.gvsig3d.simbology3D.geometry3D.Point3DGeometryGenerator;

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

import org.gvsig.osgvp.core.osgtext.Text;

import org.gvsig.osgvp.core.osgtext.TextBase;

import org.gvsig.osgvp.exceptions.node.NodeException;

import org.gvsig.osgvp.features.PixelPoint;

import org.gvsig.osgvp.geometries.Geometry;

import org.gvsig.osgvp.geometries.Point3D;

import org.gvsig.osgvp.symbology.CircleSymbol;

import org.gvsig.osgvp.symbology.CompositeSymbol3D;

import org.gvsig.osgvp.symbology.FadeTextSymbol;

import org.gvsig.osgvp.symbology.PointSymbol3D;

import org.gvsig.osgvp.symbology.PolylineSymbol3D;

import org.gvsig.osgvp.symbology.TextSymbol;

import org.gvsig.osgvp.symbology.visitor.Symbol3DVisitor;

import org.gvsig.osgvp.terrain.Terrain;

import org.gvsig.osgvp.terrain.TerrainViewer;

import org.gvsig.osgvp.viewer.IViewerContainer;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.values.NumericValue;

import com.hardcode.gdbms.engine.values.Value;

import com.iver.ai2.gvsig3d.map3d.layers.Layer3DProps;

import com.iver.cit.gvsig.exceptions.expansionfile.ExpansionFileReadException;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.ILabelable;

import com.iver.cit.gvsig.fmap.core.symbols.ILineSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.ISymbol;

import com.iver.cit.gvsig.fmap.core.v02.FTextLayout;

import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.ISpatialDB;

import com.iver.cit.gvsig.fmap.layers.ReadableVectorial;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.fmap.rendering.IClassifiedVectorLegend;

import com.iver.cit.gvsig.fmap.rendering.IVectorLegend;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.AttrInTableLabelingStrategy;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.ILabelingStrategy;

public class VectorCacheService extends CacheService {

        private IViewerContainer _canvas3D;

        private TerrainViewer _terrainViewer;

        private Terrain _terrain;

        private Extent _extent;

        private Rectangle2D _lyrExtentRect;

        private FLayer _layer;

        private IProjection _viewProj;

        // vector caching for libJOSG

        private Group _layerNode;

        private Node _currentNode;

        private int _currentGeomType;

        private List<ILabel3D> _labels;

        private float _heigth = 5000;

        private int _fontSize = 14;

        private int _n = 0;

        // Create a hash table

        private int _option;

        private boolean _primera = true;

        private static Logger _logger = Logger.getLogger(VectorCacheService.class

                        .getName());

        protected int _layermode;

        public static class LayerMode {

                public static final int POINT = 0;

                public static final int POLYLINE = 1;

                public static final int POLYGON = 2;

        }

        private static Logger logger = Logger.getLogger(VectorCacheService.class

                        .getName());

        // private ISymbol _currentSymbol;

        public VectorCacheService(IViewerContainer canvas3D, Terrain terrain,

                        String name, FLayer layer, IProjection viewProj) {

                super(terrain.getTerrainName(), name);

                // getNames();

                _canvas3D = canvas3D;

                _terrainViewer = (TerrainViewer) canvas3D.getOSGViewer();

                _terrain = terrain;

                _layer = layer;

                _viewProj = viewProj;

                _layerNode = new Group();

                _layerNode.setNodeName("layer3DVector");

                try {

                        _terrainViewer.addFeature(_layerNode);

                } catch (NodeException e1) {

                        logger.error("Command: "

                                        + "Error adding new child node to the special node.", e1);

                }

                int cacheType = CacheService.GLOBAL;

                if (terrain.getCoordinateSystemType() == Terrain.CoordinateSystemType.GEOCENTRIC)

                        cacheType += SPHERIC;

                else

                        cacheType += PLANE;

                setCacheType(cacheType);

                try {

                        _lyrExtentRect = _layer.getFullExtent();

                } catch (ExpansionFileReadException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (ReadDriverException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                _extent = new Extent(_lyrExtentRect);

        }

        // uses a strategy to get all features from layer and their symbols

        // and add them to the planet

        public void addFeaturesToTerrain() {

                try {

                        newDraw();

                        getNames();

                        // _canvas3D.repaint();

                } catch (Exception e) {

                        e.printStackTrace();

                }

        }

        public void refreshFeaturesToTerrain() {

                if (_layerNode.getNumChildren() > 0) {

                        this.deleteFeaturesToTerrain();

                        _layerNode = new Group();

                }

                try {

                        _terrainViewer.addFeature(_layerNode);

                } catch (NodeException e1) {

                        logger.error("Command: "

                                        + "Error adding new child node to the special node.", e1);

                }

                _currentGeomType = -1;

                try {

                        newDraw();

                        getNames();

                } catch (Exception e) {

                        e.printStackTrace();

                }

        }

        public void deleteFeaturesToTerrain() {

                try {

                        _layerNode.removeChildren();

                        _terrainViewer.removeFeature(_layerNode);

                        _layerNode = null;

                } catch (NodeException e) {

                        logger.error("Command: "

                                        + "Error removing new child node to the special node.", e);

                }

        }

        public void refreshFeaturesToTerrain(boolean visible) {

                _layerNode.setNodeMask(visible ? 0xffffffff : 0x00000000);

        }

        private void getNames() {

                Group root = new Group();

                createLabels(_layer);

                Layer3DProps props3D = Layer3DProps.getLayer3DProps(_layer);

                if ((_labels != null) && (_labels.size() > 0))

                        try {

                                this._layerNode.addChild(FeatureFactory.insertLabels(

                                                this._labels, this._terrain, props3D.getHeigth()));

                        } catch (NodeException e) {

                                logger.error("Command: " + "Error adding new child node.", e);

                        }

        }

        public void createLabels(FLayer lyrVect) {

                // Cleaning the m_label list

                _labels = new ArrayList<ILabel3D>();

                // If this layer had enable the labels, we would need to get its.

                if (lyrVect instanceof ILabelable && ((FLyrVect) lyrVect).isLabeled()) {

                        // Casting the layer to the interface

                        ILabelable lyrLable = (ILabelable) lyrVect;

                        // Getting the strategy

                        AttrInTableLabelingStrategy strategy = (AttrInTableLabelingStrategy) lyrLable

                                        .getLabelingStrategy();

                        // Getting the fields and Id to get after the values using the

                        // recorset.

                        try {

                                // Getting fields

                                // Text

                                int textFieldId = strategy.getTextFieldId();

                                // String textField = strategy.getTextField();

                                // Height

                                String heightField = strategy.getHeightField();

                                int heightFieldId = strategy.getHeightFieldId();

                                // Rotation

                                String rotationField = strategy.getRotationField();

                                int rotationFieldId = strategy.getRotationFieldId();

                                // Unit

                                int unit = strategy.getUnit();

                                // Getting the recordset

                                ReadableVectorial source = ((FLyrVect) lyrVect).getSource();

                                SelectableDataSource recordSet = source.getRecordset();

                                Layer3DProps props3D = Layer3DProps.getLayer3DProps(_layer);

                                float heigth = props3D.getHeigth();

                                // Iterate over all the rows.

                                for (int i = 0; i < recordSet.getRowCount(); i++) {

                                        // Getting the geometry from the source

                                        IGeometry geom = source.getShape(i);

                                        // Getting the row with all the fields relactionship.

                                        Value[] vv = recordSet.getRow(i);

                                        Value texto = vv[textFieldId];

                                        double size = 0;

                                        if (strategy.usesFixedSize()) {

                                                size = strategy.getFixedSize();

                                        } else {

                                                NumericValue altura = (NumericValue) vv[heightFieldId];

                                                size = altura.doubleValue();

                                        }

                                        SimpleLabel3D simpleLabel3DAux = new SimpleLabel3D(geom

                                                        .createLabels(0, true)[0]);

                                        Vec3 position = simpleLabel3DAux.getPosition();

                                        // Vec3 newPosition = new Vec3(position.x(), position.y(),

                                        // heigth);

                                        Vec3 newPosition = new Vec3(position.x(), position.y(),

                                                        heigth + 50);

                                        simpleLabel3DAux.setPosition(newPosition);

                                        simpleLabel3DAux.setTextField(texto.toString());

                                        simpleLabel3DAux.setHeightField(size);

                                        simpleLabel3DAux.setStrategy(strategy);

                                        Value rotacion;

                                        if (rotationField != null)

                                                rotacion = vv[rotationFieldId];

                                        simpleLabel3DAux.setUnits(unit);

                                        _labels.add(simpleLabel3DAux);

                                }

                        } catch (ReadDriverException e) {

                                e.printStackTrace();

                        }

                }

        }

        public void newDraw() {

                Node root = new Node();

                System.err.println("new Draw");

                FLyrVect fLyrVect = (FLyrVect) _layer;

                try {

                        IVectorLegend legend = (IVectorLegend) fLyrVect.getLegend();

                        ArrayList<String> fieldList = new ArrayList<String>();

                        // fields from legendn

                        String[] aux = null;

                        if (legend instanceof IClassifiedVectorLegend) {

                                aux = ((IClassifiedVectorLegend) legend)

                                                .getClassifyingFieldNames();

                                for (int i = 0; i < aux.length; i++) {

                                        fieldList.add(aux[i]);

                                }

                        }

                        FLyrVect lyrVect = null;

                        if (_layer.getClass().equals(FLyrVect.class)) {

                                lyrVect = (FLyrVect) _layer;

                        }

                        if (lyrVect != null) {

                                if (lyrVect.isLabeled()) {

                                        aux = lyrVect.getLabelingStrategy().getUsedFields();

                                        for (int i = 0; i < aux.length; i++) {

                                                fieldList.add(aux[i]);

                                        }

                                }

                        }

                        ILabelingStrategy labelStrategy = fLyrVect.getLabelingStrategy();

                        if (labelStrategy != null) {

                                String[] usetFields = labelStrategy.getUsedFields();

                        }

                        ReadableVectorial source = fLyrVect.getSource();

                        root = Symbology3DFactory.getNodeSymbol(_layer, source, fieldList

                                        .toArray(new String[fieldList.size()]), _viewProj, legend,

                                        _terrain);

                        try {

                                this._layerNode.addChild(root);

                        } catch (NodeException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                } catch (ReadDriverException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

}