Application: gvSIG desktop

package com.iver.ai2.gvsig3d.cacheservices;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Vector;

import org.cresques.cts.IProjection;

import org.cresques.px.Extent;

import org.gvsig.cacheservice.CacheService;

import org.gvsig.cacheservice.CacheServiceException;

import org.gvsig.cacheservice.RasterCacheService;

import org.gvsig.cacheservice.TileNum;

import org.gvsig.fmap.raster.layers.FLyrRasterSE;

import org.gvsig.remoteClient.utils.Utilities;

import org.gvsig.remoteClient.wcs.WCSStatus;

import org.gvsig.remoteClient.wms.ICancellable;

import org.gvsig.remoteClient.wms.WMSStatus;

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

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

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

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.drivers.wcs.FMapWCSDriver;

import com.iver.cit.gvsig.fmap.drivers.wcs.FMapWCSDriverFactory;

import com.iver.cit.gvsig.fmap.drivers.wms.FMapWMSDriver;

import com.iver.cit.gvsig.fmap.drivers.wms.FMapWMSDriverFactory;

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

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

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

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

import com.iver.utiles.FileUtils;

import com.iver.utiles.swing.threads.Cancellable;

import es.upv.ai2.libjosg.planets.Planet;

import es.upv.ai2.libjosg.planets.Planet.PlanetType;

public class FLayerCacheService extends RasterCacheService {

        private boolean     _loadFailed = true;

        private Extent      _extent;

        private Rectangle2D _lyrExtentRect;

        private FLayer      _layer;

        private IProjection _viewProj;

        private int         _dataType;

        // WMS terrain

        // TODO Un toggle this comment to use WMS and WCS extensions.

        FMapWMSDriver _wmsDriver = null;

        FMapWCSDriver _wcsDriver = null;

        WMSStatus     _wmsStatus = null;

        WCSStatus     _wcsStatus = null;

        public FLayerCacheService(Planet planet, String name, FLayer layer, IProjection viewProj) {

                super(planet.getPlanetName(), name);

                _layer = layer;

                _viewProj = viewProj;

                _loadFailed = true;

                int cacheType = CacheService.GLOBAL;

                if (planet.getType()==PlanetType.GEOCENTRIC)

                    cacheType += SPHERIC;

                else

                     cacheType += PLANE;

                setCacheType(cacheType);

                try {

                        _lyrExtentRect = _layer.getFullExtent();

                } catch (ExpansionFileReadException e) {

                        e.printStackTrace();

                } catch (ReadDriverException e) {

                        e.printStackTrace();

                }

                _extent = new Extent(_lyrExtentRect);

                Layer3DProps props3D = Layer3DProps.getLayer3DProps(layer);

                _dataType = props3D.getType();

                if (_dataType==Layer3DProps.layer3DImage)

                        setFileExtension(".png");

                else

                        setFileExtension(".tif");

                _loadFailed = false;

        }

    protected class MyCancel implements Cancellable, ICancellable {

                public boolean isCanceled() {

                        return false;

                }

                public void setCanceled(boolean canceled) {

                }

                public Object getID() {

                        return null;

                }

    }

        private Image getTileFromLayer(String fName, Rectangle2D tileExtent)

        {

                BufferedImage image;

                if (_dataType==Layer3DProps.layer3DImage) {

                        int size = getTileSize();

                        image = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);

                        ViewPort vp = new ViewPort(_viewProj);

                        vp.setExtent(tileExtent); // the real extent of the tile

                        vp.setAdjustable(false);

                vp.setImageSize(new Dimension(size, size));

                Graphics2D graphics = image.createGraphics();

                Color backgColor = new Color(255, 255, 255, 0); // transparent background

                graphics.setColor(backgColor);

                graphics.fillRect(0, 0, size, size);

        //        CancelDraw canceldraw = new MapControl.CancelDraw();

        //        canceldraw.setCanceled(false);

                // For now we'll use a trick to make sure the layer is drawn

                // even if it has scale dependency

                // In the future, a scale corresponding to the tile should be passed

                double scale = 0.5*(_layer.getMaxScale()+_layer.getMinScale());

                                        // Generate layers 3D properties

                        Layer3DProps props3D = Layer3DProps.getLayer3DProps(_layer);

                        // Getting layer transparency

                        int trans = ((FLyrDefault)_layer).getTransparency();

                        // Casting to float

                        float transFloat = (float) ((float) trans/255.0);

                        // Setting in the layers 3D props

                        props3D.setOpacity(transFloat);

                        // fix opaque the layer to save in disk 

                        ((FLyrDefault)_layer).setTransparency(255);

                try {

                                _layer.draw(image, graphics, vp, new MyCancel(), scale);

                        } catch (ReadDriverException e) {

                                e.printStackTrace();

                        }

                        // fix the real transparency to the layer

                        ((FLyrDefault)_layer).setTransparency(trans);

                try {

                                File file = new File(fName);

                                String format = getFileExtension().substring(1);

                                saveCachedFile(image, format, file);

                        } catch (IOException e1) {

                                e1.printStackTrace();

                                return null;

                        }

                        return image;

                }

                else { // Elevation data

                        // RASTER_GRID

            if (_layer instanceof FLyrRasterSE) {

                    //Grid grid = null;

                            FLyrRasterSE rasterLayer = (FLyrRasterSE)_layer;

                            //grid = rasterLayer.getSource().getGrid();

                    //if (grid == null)

                            //return null;

                            /*BufferFactory bufferFactory = rasterLayer.getDatasource();

                                int bands[] = {0};

                                bufferFactory.setDrawableBands(bands);

                                bufferFactory.setNoDataValue(0.0);

                                bufferFactory.setAreaOfInterest(tileExtent.getMinX(),

                                                tileExtent.getMinY(), tileExtent.getMaxX(), tileExtent

                                                                .getMaxY(), 32, 32);

                                RasterBuffer raster = (RasterBuffer) bufferFactory

                                                .getRasterBuf();

                                try {

                                        // raster.save(fName, new Extent(tileExtent));

                                        WriterBufferServer bufferServer = new WriterBufferServer(

                                                        raster);

                                        Params p = GeoRasterWriter.getWriter(fName).getParams();

                                        AffineTransform at = new AffineTransform(tileExtent

                                                        .getWidth() / 32, 0, 0,

                                                        -(tileExtent.getHeight() / 32), tileExtent

                                                                        .getMinX(), tileExtent.getMaxY());

                                        GeoRasterWriter grw = GeoRasterWriter.getWriter(

                                                        bufferServer, fName, 1, at, raster.getWidth(),

                                                        raster.getHeight(), raster.getDataType(), p, null);

                                        // grw.setWkt(d.getWktProjection());

                                        grw.dataWrite();

                                        grw.writeClose();

                                } catch (NotSupportedExtensionException e) {

                                        e.printStackTrace();

                                } catch (RasterDriverException e) {

                                        e.printStackTrace();

                                } catch (IOException e) {

                                        e.printStackTrace();

                                }

*/

                        }

                        // TODO  Un toggle this comment to use WCS and WMS extensions.

                        else

                        if (_layer instanceof FLyrWMS) { // WMS Elevation

                                try {  

                                        FLyrWMS wmsLayer = (FLyrWMS)_layer;

                                        if (_wmsDriver == null) {

                                            URL host = wmsLayer.getHost();

                                          _wmsDriver = FMapWMSDriverFactory.getFMapDriverForURL(host);

                                        }

                                        if (_wmsStatus == null) {

                                              _wmsStatus = new WMSStatus();

                                              _wmsStatus.setFormat(wmsLayer.getFormat());

                                              _wmsStatus.setHeight(32);

                                              _wmsStatus.setWidth(32);

                                              _wmsStatus.setLayerNames(Utilities.createVector(wmsLayer.getLayerQuery(),","));

                                              _wmsStatus.setSrs(wmsLayer.getSRS());

                                              HashMap props = wmsLayer.getProperties();

                                              Vector styles;

                                              Vector dimensions;

                                              styles = (Vector)(props.get("styles"));

                                              dimensions = (Vector)(props.get("dimensions"));

                                              _wmsStatus.setStyles(styles);

                                              _wmsStatus.setDimensions(dimensions);

                                              _wmsStatus.setTransparency(false);

                                              String getMapStr = wmsLayer.getOnlineResource("GetMap");

                                              _wmsStatus.setOnlineResource(getMapStr);

                                        }

                                        _wmsStatus.setExtent(tileExtent);

                                      File f = _wmsDriver.getMap(_wmsStatus, new MyCancel());

                                          if (f == null)

                                                  return null;

                                          FileUtils.copy(f, new File(fName));

                                          String fileName = f.getPath();

//                                          System.out.println(fileName);

                                } catch (Exception e) {

                                        return null;

                                }

                        }

                        else

                                if (_layer instanceof FLyrWCS) { // WCS Elevation

                                        try { 

                                                FLyrWCS wcsLayer = (FLyrWCS)_layer;

                                                if (_wcsDriver == null) {

                                                    URL host = wcsLayer.getHost();

                                                  _wcsDriver = FMapWCSDriverFactory.getFMapDriverForURL(host);

                                                }

                                                if (_wcsStatus == null) {

                                                      _wcsStatus = new WCSStatus();

                                                      Hashtable props = wcsLayer.getProperties();

                                                      _wcsStatus.setCoveraName((String)props.get("name"));

                                                      _wcsStatus.setFormat((String)props.get("format"));

                                                      _wcsStatus.setHeight(32);

                                                      _wcsStatus.setWidth(32);

                                                      _wcsStatus.setSrs((String)props.get("crs"));

                                                      _wcsStatus.setParameters((String)props.get("parameter"));

                                                      String time = (String)props.get("time");

                                                      if (time.length()>0)

                                                          _wcsStatus.setTime(time);

//                                                      _wcsStatus.setOnlineResource(wcsLayer.getOnlineResource("GetCoverage"));

                                                }

                                                _wcsStatus.setExtent(tileExtent);

                                                  File f = _wcsDriver.getCoverage(_wcsStatus, new MyCancel());

                                                  if (f == null)

                                                          return null;

                                                  FileUtils.copy(f, new File(fName));

                                                  String fileName = f.getPath();

//                                                  System.out.println(fileName);

                                        } catch (Exception e) {

                                                return null;

                                        }

                                }/**/

                        return null; // no image

                }

        }

        public String getTileAsFName(TileNum t) throws CacheServiceException {

                if(_loadFailed) { throw new CacheServiceException(new Exception()); }

                String tileId = t.numToOpTileId();

                String fName = getTileFileName(t);

//                System.out.println("CMTexture2D: requestTexture: "+tileId);

                if (!new File(fName).exists()) {

                        Rectangle2D tileExtent = computeBBox(t);

                        getTileFromLayer(fName, tileExtent);

                }

                return fName;

        }

        public Image getTileAsImage(TileNum tileNum) throws CacheServiceException {

                if(_loadFailed) { throw new CacheServiceException(new Exception()); }

                String tileId = tileNum.numToOpTileId();

                String fName = getTileFileName(tileNum);

//                System.out.println("CMTexture2D: requestTexture: "+tileId);

                Rectangle2D tileExtent = computeBBox(tileNum);

                return getTileFromLayer(fName, tileExtent);

        }

        public boolean intersectsLayer(TileNum tileNum) {

                Rectangle2D tileExtent = computeBBox(tileNum);

                // TODO: use a reprojected layer extent !!!

                /*System.err.println("TILE: ("+tileExtent.getMinX()+","+tileExtent.getMinY()+"),("+

                                tileExtent.getMaxX()+","+tileExtent.getMaxY()+")");

                System.err.println("CAPA: ("+_lyrExtentRect.getMinX()+","+_lyrExtentRect.getMinY()+"),("+

                                _lyrExtentRect.getMaxX()+","+_lyrExtentRect.getMaxY()+")");

                System.err.println("INTERSECTA LA CAPAAAAAA??????????:"+_lyrExtentRect.intersects(tileExtent));

                return (_lyrExtentRect.intersects(tileExtent));*/

                return Math.max(_lyrExtentRect.getMinX(),tileExtent.getMinX()) <= Math.min(_lyrExtentRect.getMaxX(),tileExtent.getMaxX()) &&

                Math.max(Math.min(_lyrExtentRect.getMinY(),_lyrExtentRect.getMaxY()),tileExtent.getMinY()) <= Math.min(Math.max(_lyrExtentRect.getMinY(),_lyrExtentRect.getMaxY()),tileExtent.getMaxY());

        }

}