Application: gvSIG desktop » gvSIG 3D

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright � 2007-2015 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.swing.impl.data;

import gov.nasa.worldwind.WWObjectImpl;

import gov.nasa.worldwind.WorldWind;

import gov.nasa.worldwind.avlist.AVKey;

import gov.nasa.worldwind.avlist.AVList;

import gov.nasa.worldwind.cache.BasicRasterServerCache;

import gov.nasa.worldwind.cache.MemoryCache;

import gov.nasa.worldwind.data.BufferedImageRaster;

import gov.nasa.worldwind.data.ByteBufferRaster;

import gov.nasa.worldwind.data.CachedDataRaster;

import gov.nasa.worldwind.data.DataRaster;

import gov.nasa.worldwind.data.DataRasterReader;

import gov.nasa.worldwind.data.DataRasterReaderFactory;

import gov.nasa.worldwind.data.RasterServer;

import gov.nasa.worldwind.formats.dds.DDSCompressor;

import gov.nasa.worldwind.geom.Sector;

import gov.nasa.worldwind.retrieve.Retriever;

import gov.nasa.worldwind.util.ImageUtil;

import java.awt.Transparency;

import java.io.IOException;

import java.nio.ByteBuffer;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.view3d.lib.api.properties.E3DLayerLoadingModes;

import org.gvsig.view3d.swing.api.MapControl3D;

import org.gvsig.view3d.swing.impl.DefaultMapControl3D;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementaion of {@link RasterServer}. This class representes a server

 * that serves raster information to {@link Retriever}.

 * 

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

 */

public class DefaultRasterServer extends WWObjectImpl implements RasterServer {

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultRasterServer.class);

    protected static final MemoryCache cache = new BasicRasterServerCache();

    private DataRaster dataRaster;

    /**

     * Default constructor as from params. Required params:

     * 

     * <ul>

     * <li>DefaultMapControl3D.GVSIG_MAPCONTROL3D</li>

     * <li>DefaultMapControl3D.GVSIG_LAYER</li>

     * </ul>

     * 

     * @param rasterServerParams parameters to create <code>RasterServer</code>

     */

    public DefaultRasterServer(AVList params) {

        if (params == null) {

            LOG.error("Can't create raster server, raster server parameters are null");

            throw new IllegalArgumentException();

        }

        MapControl3D mapControl3D =

            (MapControl3D) params.getValue(DefaultMapControl3D.GVSIG_MAPCONTROL3D);

        if (mapControl3D == null) {

            LOG.error(

                "Can not create raster server, missing required parameter: {}",

                DefaultMapControl3D.GVSIG_MAPCONTROL3D);

            throw new IllegalArgumentException();

        }

        FLayer layer = (FLayer) params.getValue(E3DLayerLoadingModes.GVSIG_LAYER);

        if (layer == null) {

            LOG.error(

                "Can not create raster server, missing required parameter: {}",

                E3DLayerLoadingModes.GVSIG_LAYER);

            throw new IllegalArgumentException();

        }

        this.setValues(params);

        DataRasterReaderFactory readerFactory =

            (DataRasterReaderFactory) WorldWind

                .createConfigurationComponent(AVKey.DATA_RASTER_READER_FACTORY_CLASS_NAME);

        DataRasterReader reader =

            readerFactory.findReaderFor(layer, params.copy());

        try {

            this.dataRaster =

                new CachedDataRaster(layer, params.copy(), reader, cache);

        } catch (IllegalArgumentException e) {

            LOG.error(

                "Illegal argument, cached data raster can't be created with this parameters {}",

                new Object[] { layer.getInfoString(), params.toString(),

                    reader.getDescription(), cache.getName() });

            return;

        } catch (IOException e) {

            LOG.error("Can't read {} with {}", layer.getInfoString(), reader.getDescription());

            return;

        }

    }

    public ByteBuffer getRasterAsByteBuffer(AVList params) {

        DataRaster raster = this.composeRaster(params);

        String format = (String) params.getValue(AVKey.IMAGE_FORMAT);

        if (raster instanceof BufferedImageRaster) {

            if ("image/png".equalsIgnoreCase(format)) {

                return ImageUtil.asPNG(raster);

            } else if ("image/jpg".equalsIgnoreCase(format)

                || "image/jpeg".equalsIgnoreCase(format)) {

                return ImageUtil.asJPEG(raster);

            } else if ("image/dds".equalsIgnoreCase(format)) {

                return DDSCompressor

                    .compressImage(((BufferedImageRaster) raster)

                        .getBufferedImage());

            }

        } else if (raster instanceof ByteBufferRaster) {

            // Elevations as BIL16 or as BIL32 are stored in the simple

            // ByteBuffer object

            return ((ByteBufferRaster) raster).getByteBuffer();

        } else {

            LOG.error("Unexpected raster type {}", raster

                .getClass().getName());

            throw new IllegalArgumentException();

        }

        return null;

    }

    public Sector getSector() {

        return (Sector) this.getValue(AVKey.SECTOR);

    }

    private DataRaster composeRaster(AVList reqParams) {

        DataRaster reqRaster;

        if (reqParams == null) {

            LOG.error("Can't compose raster, parameters are null");

            throw new IllegalArgumentException();

        }

        if (!reqParams.hasKey(AVKey.WIDTH)) {

            LOG.error("Can't compose raster, missing required parameter: {}",

                AVKey.WIDTH);

            throw new IllegalArgumentException();

        }

        if (!reqParams.hasKey(AVKey.HEIGHT)) {

            LOG.error("Can't compose raster, missing required parameter: {}",

                AVKey.HEIGHT);

            throw new IllegalArgumentException();

        }

        Object o = reqParams.getValue(AVKey.SECTOR);

        if (null == o || !(o instanceof Sector)) {

            LOG.error("Can't compose raster, missing required parameter: {}",

                AVKey.SECTOR);

            throw new IllegalArgumentException();

        }

        Sector reqSector = (Sector) o;

        Sector rasterExtent = this.getSector();

        if (!reqSector.intersects(rasterExtent)) {

            LOG.error("Can't compose raster, requerided sector does not intersect with raster server sector");

            throw new IllegalArgumentException();

        }

        int reqWidth = (Integer) reqParams.getValue(AVKey.WIDTH);

        int reqHeight = (Integer) reqParams.getValue(AVKey.HEIGHT);

        if (!reqParams.hasKey(AVKey.BYTE_ORDER)) {

            reqParams.setValue(AVKey.BYTE_ORDER, AVKey.BIG_ENDIAN);

        }

        if (AVKey.ELEVATION.equals(this.getValue(AVKey.PIXEL_FORMAT))) {

            reqParams.setValue(AVKey.PIXEL_FORMAT, AVKey.ELEVATION);

            if (!reqParams.hasKey(AVKey.DATA_TYPE)) {

                LOG.error("Missing requerided parameter {}", AVKey.DATA_TYPE,

                    new IllegalArgumentException());

            }

            String dataType = (String) reqParams.getValue(AVKey.DATA_TYPE);

            int bytesNumber = getBytesNumber(dataType);

            ByteBuffer byteBuffer =

                ByteBuffer.allocate(reqWidth * reqHeight * bytesNumber);

            reqRaster =

                new ByteBufferRaster(reqWidth, reqHeight, reqSector,

                    byteBuffer, reqParams);

        } else if (AVKey.IMAGE.equals(this.getValue(AVKey.PIXEL_FORMAT))) {

            reqParams.setValue(AVKey.PIXEL_FORMAT, AVKey.IMAGE);

            reqRaster =

                new BufferedImageRaster(reqWidth, reqHeight,

                    Transparency.TRANSLUCENT, reqSector);

        } else {

            LOG.error("Unrecognized type of pixel format: {}",

                this.getValue(AVKey.PIXEL_FORMAT));

            throw new IllegalArgumentException();

        }

        this.dataRaster.drawOnTo(reqRaster);

        return reqRaster;

    }

    private int getBytesNumber(String dataType) {

        if (AVKey.INT8.equals(dataType)) {

            return 1;

        } else if (AVKey.INT16.equals(dataType)) {

            return 2;

        } else if (AVKey.INT32.equals(dataType)

            || AVKey.FLOAT32.equals(dataType)) {

            return 4;

        } else if (AVKey.FLOAT64.equals(dataType)) {

            return 8;

        }

        return 1;

    }

}