Application: gvSIG desktop

package org.gvsig.raster.tools.lib.impl;

import java.io.File;

import java.io.IOException;

import java.util.List;

import org.apache.commons.io.FileUtils;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

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

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

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

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

import org.gvsig.fmap.dal.raster.api.NewRasterStoreParameters;

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

import org.gvsig.fmap.dal.raster.api.RasterStore;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

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

import org.gvsig.fmap.mapcontext.raster.api.RasterLayer;

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

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

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

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

import org.gvsig.raster.tools.lib.api.RasterClip;

import org.gvsig.raster.tools.lib.api.exceptions.ClipException;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 * @author fdiaz

 *

 */

public class DefaultRasterClip implements RasterClip {

    private RasterLayer layer;

    private Envelope envelope;

    private double pixelSizeX;

    private double pixelSizeY;

    private int interpolationMethod;

    private List<Integer> bands;

    private String layerNamePrefix;

    private boolean createOneLayerPerBand;

    private boolean saveToNewRasterFile;

    private File folder;

    private int columns;

    private int rows;

    /**

     *

     */

    public DefaultRasterClip() {

    }

    public RasterLayer getLayer() {

        return layer;

    }

    public void setLayer(RasterLayer layer) {

        this.layer = layer;

    }

    @Override

    public void execute(SimpleTaskStatus taskStatus) throws ClipException {

        MapContext mapContext = this.layer.getMapContext();

        ICoordTrans ct = layer.getCoordTrans();

        Envelope envelopeInLayerProj = this.getEnvelope();

        Envelope envelopeInRasterProj = envelopeInLayerProj;

        double pixelSizeX = this.getPixelSizeX();

        double pixelSizeY = this.getPixelSizeY();

        if (ct != null) {

            envelopeInRasterProj = envelopeInLayerProj.convert(ct.getInverted());

            pixelSizeX = this.getPixelSizeX() * envelopeInRasterProj.getLength(0) / envelopeInLayerProj.getLength(0);

            pixelSizeY = this.getPixelSizeY() * envelopeInRasterProj.getLength(1) / envelopeInLayerProj.getLength(1);

        }

        RasterQuery rasterQuery = layer.createRasterQuery();

        rasterQuery.setPixelSize(pixelSizeX);

        rasterQuery.setClip(envelopeInRasterProj);

        RasterStore rasterStore = layer.getRasterStore();

        for (Integer bandNumber : bands) {

            rasterStore.createBandQuery(bandNumber);

            rasterQuery.addBand(rasterStore.createBandQuery(bandNumber));

        }

        Buffer clipped = null;

        Buffer firstInterpolated = null;

        Buffer converted = null;

        Buffer interpolated = null;

        try {

            try {

                clipped = rasterStore.getRasterSet(rasterQuery);

            } catch (DataException e) {

                throw new ClipException("Can't create the raster clip.", e);

            }

            firstInterpolated = clipped;

            //FIXME: Creo que no es necesaria esta primera interpolaci?n, la dejo comentarizada, de momento por si cambiamos de idea.

//            if(ct != null && Math.abs(envelopeInLayerProj.getLength(0)/clipped.getColumns()-pixelSizeX)>0.01){

//                if (converted.getColumns() != this.getColumns() || converted.getRows() != this.getRows()) {

//                    try {

//                        firstInterpolated =

//                            clipped.createInterpolated(

//                                (int)Math.floor(envelopeInLayerProj.getLength(1)/pixelSizeY),

//                                (int)Math.floor(envelopeInLayerProj.getLength(0)/pixelSizeX),

//                                interpolationMethod,

//                                taskStatus);

//                    } catch (LocatorException | BufferException e) {

//                        throw new ClipException("Can't interpolate buffer.", e);

//                    }

//                }

//            }

            converted = firstInterpolated;

            if (ct != null) {

                try {

                    converted = firstInterpolated.convert(ct, taskStatus);

                } catch (BufferException e) {

                    throw new ClipException("Can't convert buffer from '" + ct.getPDest().getAbrev() + "' to '"

                        + ct.getPOrig().getAbrev() + "'.", e);

                }

            }

            interpolated = converted;

            if (converted.getColumns() != this.getColumns() || converted.getRows() != this.getRows()) {

                try {

                    interpolated =

                        converted.createInterpolated(this.getRows(), this.getColumns(), interpolationMethod, taskStatus);

                } catch (LocatorException | BufferException e) {

                    throw new ClipException("Can't interpolate buffer.", e);

                }

            }

            String layerName = layerNamePrefix;

            if(this.createOneLayerPerBand){

                List<Buffer> buffers = BufferLocator.getBufferManager().createOneBufferPerBand(interpolated, true);

                int counter = 0;

                for (Buffer buffer : buffers) {

                    BandInfo bandInfo = buffer.getBands()[0].getBandInfo();

                    String bandLayerName = layerName+" - B"+counter; //bandInfo.getBand()+" - "+bandInfo.getName();

                    bandLayerName = getFreeLayerName(mapContext, bandLayerName);

                    File file = exportBuffer(buffer, bandLayerName);

                    mapContext.getLayers().add(createLayer(interpolated.getProjection(), bandLayerName, file));

                    counter++;

                }

            } else {

                layerName = getFreeLayerName(mapContext, layerName);

                File file = exportBuffer(interpolated, layerName);

                mapContext.getLayers().add(createLayer(interpolated.getProjection(), layerName, file));

            }

        } catch (IOException | ValidateDataParametersException | DataException | LocatorException | BufferException | LoadLayerException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } finally {

            DisposeUtils.dispose(clipped);

            DisposeUtils.dispose(converted);

            DisposeUtils.dispose(interpolated);

        }

    }

    /**

     * @param interpolated

     * @param layerName

     * @param file

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     * @throws ValidateDataParametersException

     * @throws ClipException

     * @throws LoadLayerException

     */

    private FLayer createLayer(IProjection proj, String layerName, File file) throws InitializeException,

        ProviderNotRegisteredException, ValidateDataParametersException, ClipException, LoadLayerException {

        DataManager manager = DALLocator.getDataManager();

        DataServerExplorerParameters explorerParams =

            manager.createServerExplorerParameters(FilesystemServerExplorer.NAME);

        FilesystemServerExplorer explorer =

            (FilesystemServerExplorer) manager

                .openServerExplorer(FilesystemServerExplorer.NAME, explorerParams);

        String type = explorer.getProviderName(file);

        DynObject params = manager.createStoreParameters(type);

        if (params.getDynClass().getDynField("file") != null) {

            params.setDynValue("file", file);

        }

        if (params.getDynClass().getDynField("crs") != null) {

            params.setDynValue("crs", proj);

        }

        RasterStore store = null;

        try {

            store = (RasterStore) manager.openStore(type, params);

            // store = (RasterStore) manager.openStore("PNG", params);

        } catch (ValidateDataParametersException | InitializeException | ProviderNotRegisteredException e) {

            throw new ClipException("Can't open store.", e);

        }

        MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

        FLayer newLayer = mapContextManager.createLayer(layerName, store);

        return newLayer;

    }

    /**

     * @param mapContext

     * @param layerName

     * @return

     */

    private String getFreeLayerName(MapContext mapContext, String layerName) {

        int counter = 1;

        FLayer newLayer = mapContext.getLayers().getLayer(layerName);

        while (newLayer != null) {

            layerName = layerName + "_" + counter;

            newLayer = mapContext.getLayers().getLayer(layerName);

        }

        return layerName;

    }

    /**

     * @param buffer

     * @param layerName

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     * @throws IOException

     * @throws ValidateDataParametersException

     * @throws DataException

     */

    private File exportBuffer(Buffer buffer, String layerName) throws InitializeException,

        ProviderNotRegisteredException, IOException, ValidateDataParametersException, DataException {

        /* As? se crea un archivo raster tiff*/

        String providerName = "GTiff";

        String extension = "tif";

        DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices();

        DataServerExplorerParameters eparams;

        eparams = manager.createServerExplorerParameters("FilesystemExplorer");

        File destFile = null;

        if (saveToNewRasterFile && this.folder != null) {

            destFile = FileUtils.getFile(folder, layerName + "." + extension);

        } else {

            destFile = File.createTempFile(layerName, "." + extension);

        }

        File parent = destFile.getParentFile();

        if (!parent.exists()) {

            parent.mkdirs();

        }

        eparams.setDynValue("initialpath", destFile);

        DataServerExplorer serverExplorer = manager.openServerExplorer(eparams.getExplorerName(), eparams);

        NewRasterStoreParameters params = (NewRasterStoreParameters) serverExplorer.getAddParameters(providerName);

        params.setDynValue("file", destFile);

        params.setDynValue("compress", "NONE");

        params.setDynValue("tfw", false);

        int bands = this.bands.size();

        switch (bands) {

        case 3:

            params.setDynValue("photometric", "RGB");

            break;

        case 4:

            params.setDynValue("photometric", "RGB");

            params.setDynValue("alpha", "NON-PREMULTIPLIED");

            break;

        default:

            params.setDynValue("photometric", "MINISBLACK");

            break;

        }

        params.setBuffer(buffer);

        serverExplorer.add(providerName, params, true);

        return destFile;

    }

    @Override

    public void setEnvelope(Envelope envelope) {

        this.envelope = envelope;

    }

    @Override

    public Envelope getEnvelope() {

        return this.envelope;

    }

    @Override

    public void setPixelSizeX(double pixelSizeX) {

        this.pixelSizeX = pixelSizeX;

    }

    @Override

    public double getPixelSizeX() {

        return this.pixelSizeX;

    }

    @Override

    public void setPixelSizeY(double pixelSizeY) {

        this.pixelSizeY = pixelSizeY;

    }

    @Override

    public double getPixelSizeY() {

        return this.pixelSizeY;

    }

    @Override

    public void setInterpolationMethod(int interpolationMethod) {

        this.interpolationMethod = interpolationMethod;

    }

    @Override

    public int getInterpolationMethod() {

        return this.interpolationMethod;

    }

    @Override

    public void setBands(List<Integer> bands) {

        this.bands = bands;

    }

    @Override

    public List<Integer> getBands() {

        return this.bands;

    }

    @Override

    public void setLayerNamePrefix(String layerNamePrefix) {

        this.layerNamePrefix = layerNamePrefix;

    }

    @Override

    public String getLayerNamePrefix() {

        return this.layerNamePrefix;

    }

    @Override

    public void setCreateOneLayerPerBand(boolean createOneLayerPerBand) {

        this.createOneLayerPerBand = createOneLayerPerBand;

    }

    @Override

    public boolean isCreateOneLayerPerBand() {

        return this.createOneLayerPerBand;

    }

    @Override

    public void setFolder(File folder) {

        this.folder = folder;

    }

    @Override

    public File getFolder() {

        return this.folder;

    }

    @Override

    public void setSaveToNewRasterFile(boolean saveToNewRasterFile) {

        this.saveToNewRasterFile = saveToNewRasterFile;

    }

    @Override

    public boolean isSaveToNewRasterFile() {

        return this.saveToNewRasterFile;

    }

    @Override

    public int getRows() {

        return rows;

    }

    @Override

    public void setRows(int rows) {

        this.rows = rows;

    }

    @Override

    public int getColumns() {

        return columns;

    }

    @Override

    public void setColumns(int columns) {

        this.columns = columns;

    }

}