Application: gvSIG desktop

package org.gvsig.fmap.dal.raster.spi;

import java.awt.image.Raster;

//import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.exception.CloseException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.raster.BandQuery;

import org.gvsig.fmap.dal.raster.RasterQuery;

import org.gvsig.fmap.dal.raster.spi.AbstractOpenRasterStoreParameters;

import org.gvsig.fmap.dal.raster.spi.AbstractRasterStoreProvider;

import org.gvsig.fmap.dal.raster.spi.BandDescriptorServices;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

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

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.BufferDimensions;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.BufferManager;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.api.PageManager;

import org.gvsig.raster.lib.buffer.api.TileStruct;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

import org.gvsig.raster.lib.buffer.spi.DefaultTileStruct;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractAwtRasterStoreProvider extends AbstractRasterStoreProvider {

    private static final Logger logger = LoggerFactory.getLogger(AbstractAwtRasterStoreProvider.class);

    protected Envelope envelope = null;

    private IProjection projection = null;

    private Raster raster;

    private List<PageManager> pageManagers;

    private TileStruct tileStruct;

    /**

     * @param params

     * @param storeServices

     * @param metadata

     */

    public AbstractAwtRasterStoreProvider(DataStoreParameters params, DataStoreProviderServices storeServices,

        DynObject metadata) {

        super(params, storeServices, metadata);

    }

    protected void init(DataStoreParameters params, DataStoreProviderServices storeServices) throws InitializeException {

        if (params == null) {

            throw new InitializeException(

                new NullPointerException("params is null"));

        }

        this.projection=(IProjection) params.getDynValue(DataStore.METADATA_CRS);

    }

    /**

     * @param manager

     * @param image

     * @throws CreateEnvelopeException

     */

    protected void open(Raster raster) throws CreateEnvelopeException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        this.raster = raster;

        pageManagers = new ArrayList<PageManager>();

        for(int band=0; band<this.raster.getNumBands(); band++){

            BandDescriptorServices bandDescriptor = getBandDescriptor(band);

            bandDescriptor.setDataType(bufferManager.getBufferTypeFromAwtRaster(getRaster()));

            bandDescriptor.setName(String.valueOf(band));

            try {

                bandDescriptor.setDescription(this.getName()+ "- band "+band);

            } catch (Exception e) {

                bandDescriptor.setDescription("band "+band);

            }

            bandDescriptor.add("X size", this.raster.getWidth());

            bandDescriptor.add("Y size", this.raster.getHeight());

            pageManagers.add(bufferManager.createAwtRasterBandPageManager(raster, band));

        }

        if (getParameters().getWldParams()!=null){

            envelope=createWLDEnvelope(getParameters().getWldParams());

        }else{

        envelope =

            GeometryLocator.getGeometryManager().createEnvelope(0, 0,

                getRaster().getWidth(), getRaster().getHeight(), Geometry.SUBTYPES.GEOM2D);

        }

    }

    @Override

    public AbstractOpenRasterStoreParameters getParameters() {

        return (AbstractOpenRasterStoreParameters) super.getParameters();

    }

    protected boolean isOpen() {

        return this.raster!=null;

    }

    @Override

    public int getBands() {

        return this.getRaster().getNumBands();

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        int[] bandDataTypes;

        List<PageManager> pageManagers = new ArrayList<PageManager>();

        NoData[] bandNoData;

        if (rasterQuery != null && !rasterQuery.getBands().isEmpty() ) {

            List<BandQuery> bands;

            bands = rasterQuery.getBands();

            bandDataTypes = new int[bands.size()];

            bandNoData = new NoData[bands.size()];

            for (BandQuery bandQuery : bands) {

                int band = bandQuery.getBand();

                bandDataTypes[band] = this.getBandDescriptor(band).getDataType();

                bandNoData[band] = this.getNoData(rasterQuery, band);

                pageManagers.add(this.pageManagers.get(band));

            }

        } else {

            bandDataTypes = this.getDataTypes();

            bandNoData = this.getNoDatas();

            pageManagers = this.pageManagers;

        }

        Buffer buffer =

            bufferManager.createBuffer(getRaster().getHeight(), getRaster().getWidth(), bandDataTypes, bandNoData,

                projection, envelope, pageManagers);

        return buffer;

    }

    protected Envelope createWLDEnvelope(List<String> wldParams) {

        double pixelSizeX=Double.valueOf(wldParams.get(0));

        double rotationAxisY = Double.valueOf(wldParams.get(1));

        double rotationAxisX = Double.valueOf(wldParams.get(2));

        double pixelSizeY = Double.valueOf(wldParams.get(3));

        double upperLeftPixelCenterCoordX = Double.valueOf(wldParams.get(4));

        double upperLeftPixelCenterCoordY = Double.valueOf(wldParams.get(5));

        if (0.0 != rotationAxisX || 0.0 != rotationAxisY) {

            logger.warn(

                "Rotation in wld file not implemented yet. It will be ignored");

        }

        double leftMostX = upperLeftPixelCenterCoordX - (pixelSizeX * 0.5);

        double upperMostY = upperLeftPixelCenterCoordY - (pixelSizeY * 0.5);

        double height=getRaster().getHeight()*pixelSizeY;

        double width=getRaster().getWidth()*pixelSizeX;

        // double minX, double minY, double maxX, double maxY, int subType

        try {

            envelope = GeometryLocator.getGeometryManager().createEnvelope(

                Math.min(leftMostX,leftMostX + width),

                Math.min(upperMostY,upperMostY + height),

                Math.max(leftMostX,leftMostX + width),

                Math.max(upperMostY,upperMostY + height),

                Geometry.SUBTYPES.GEOM2D);

        } catch (LocatorException | CreateEnvelopeException e) {

            logger.warn(

                "Failed to create envelope from wld file with coords: minx:"+leftMostX+

                ", miny:"+upperMostY+", maxX: "+leftMostX + width+", maxY: "+upperMostY + height);

            e.printStackTrace();

        }

        return envelope;

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {

            return this.envelope;

        } else if( DataStore.METADATA_CRS.equalsIgnoreCase(name) ) {

            IProjection pro = (IProjection) this.getParameters().getDynValue(DataStore.METADATA_CRS);

            if (pro != null) {

                return pro;

            }

        }

        return super.getDynValue(name);

    }

    @Override

    public void close() throws CloseException {

        this.raster = null;

    }

    protected Raster getRaster() {

        autoOpen();

        return this.raster;

    }

    @Override

    public TileStruct getTileStruct() {

        List<Double> pixelSizes = new ArrayList<Double>();

        Map<Integer, Double> zoomLevels = new HashMap<Integer, Double>();

        if (this.tileStruct == null) {

            tileStruct = new DefaultTileStruct();

            int completeRows = getRaster().getHeight();

            int completeColumns = getRaster().getWidth();

            double completePixelSizeX = envelope.getLength(DIMENSIONS.X) / completeColumns;

            double completePixelSizeY = envelope.getLength(DIMENSIONS.Y) / completeRows;

            int maximumLength = completeColumns;

            int tileMaximumLength = tileStruct.getColumnsPerTile(); // tileSizeX;

            double maximumPixelSize = completePixelSizeX;

            if (completeRows * tileStruct.getRowsPerTile() > completeColumns * tileStruct.getColumnsPerTile()) {

                maximumLength = completeRows;

                tileMaximumLength = tileStruct.getRowsPerTile();

                maximumPixelSize = completePixelSizeY;

            }

            double pixelSize = maximumPixelSize;

            while (maximumLength * maximumPixelSize / pixelSize > tileMaximumLength) {

                pixelSizes.add(pixelSize);

                pixelSize = pixelSize * 2;

            }

            pixelSizes.add(pixelSize);

            int i = 0;

            for (int zoomLevel = pixelSizes.size() - 1; zoomLevel >= 0; zoomLevel--) {

                zoomLevels.put(i, pixelSizes.get(zoomLevel));

                i++;

            }

        }

        return tileStruct;

    }

    @Override

    public BufferDimensions getDimensions() {

        if(this.dimensions==null){;

            this.dimensions = BufferLocator.getBufferManager().createBufferDimensions(this.getRaster().getHeight(), this.getRaster().getWidth(), this.envelope);

        }

        return this.dimensions;

    }

    @Override

    protected void doDispose() throws BaseException {

        super.doDispose();

        if (pageManagers != null) {

            for (Iterator iterator = pageManagers.iterator(); iterator.hasNext();) {

                PageManager pageManager = (PageManager) iterator.next();

                DisposeUtils.dispose(pageManager);

                iterator.remove();

            }

            pageManagers = null;

        }

        if(this.tileStruct != null){

            DisposeUtils.dispose((Disposable) this.tileStruct);

            this.tileStruct = null;

        }

        raster = null;

    }

}