Application: gvSIG desktop

package org.gvsig.fmap.dal.file.bsq;

import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.gvsig.basicformats.FormatsFile;

import org.gvsig.basicformats.PRJFile;

import org.gvsig.basicformats.STXFile;

import org.gvsig.basicformats.WLDFile;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

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.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public abstract class AbstractFileRasterStoreProvider 

        extends AbstractRasterStoreProvider

        implements ResourceConsumer

    {

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

    protected Envelope envelope = null;

    protected IProjection projection = null;

    protected List<PageManager> pageManagers;

    protected TileStruct tileStruct;

    protected String storeProviderName;

    protected String storeProviderDescription;

    protected ResourceProvider resource;

    protected WLDFile wldFile;

    protected PRJFile prjFile;

    protected STXFile stxFile;

    // protected CLRFile clrFile;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public AbstractFileRasterStoreProvider(

        String storeProviderName, 

        String storeProviderDescription, 

        OpenRasterStoreParameters params,

        DataStoreProviderServices storeServices

        ) throws InitializeException {

        super(

                params,

                storeServices,

                FileHelper.newMetadataContainer(storeProviderName)

        );

        this.storeProviderName = storeProviderName;

        this.storeProviderDescription = storeProviderDescription;

        this.init(params, storeServices);

    }

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

        File file = this.getFile();

        if (file == null) {

            throw new InitializeException(

                new NullPointerException(this.storeProviderName +" file is null"));

        }

        this.wldFile = FormatsFile.getWLDFile(this.getFile());

        this.prjFile = FormatsFile.getPRJFile(this.getFile());

        this.stxFile = FormatsFile.getSTXFile(this.getFile());

        // this.clrFile = UtilsFile.createCLRFile(this.getFile());

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

        if( this.projection==null ) {

            this.projection = this.prjFile.getCRS();

        }

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

    }

    @Override

    public ResourceProvider getResource() {

        return this.resource;

    }

    protected File getFile() {

        return ((FilesystemStoreParameters)this.getParameters()).getFile();

    }

    @Override

    public Object getSourceId() {

        return this.getFile();

    }

    @Override

    public String getName() {

        String name = this.getFile().getName();

        return FilenameUtils.getBaseName(name);

    }

    @Override

    public String getFullName() {

        return this.getFile().getAbsolutePath();

    }

    @Override

    public String getProviderName() {

        return this.storeProviderName;

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

            DataStoreNotification.RESOURCE_CHANGED,

            resource);

    }

    @Override

    protected void doDispose() throws BaseException {

        super.doDispose();

    }

    @Override

    public DataServerExplorer getExplorer() throws ReadException, ValidateDataParametersException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getFile().getParent());

            return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);

        } catch (DataException | ValidateDataParametersException e) {

            throw new ReadException(this.getProviderName(), e);

        }

    }

    @Override

    public BufferDimensions getDimensions() {

        if(this.dimensions==null){

            this.dimensions = BufferLocator.getBufferManager().createBufferDimensions(

                    this.getRows(), 

                    this.getColumns(), 

                    this.getEnvelope()

            );

        }

        return this.dimensions;

    }

    @Override

    public TileStruct getTileStruct() {

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

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

        if (this.tileStruct == null) {

            tileStruct = new DefaultTileStruct();

            int completeRows = getRows();

            int completeColumns = getColumns();

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

            double completePixelSizeY = envelope.getLength(Geometry.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 Object getDynValue(String name) throws DynFieldNotFoundException {

        switch(name) {

            case DataStore.METADATA_CRS:

                return this.getProjection();

            case DataStore.METADATA_ENVELOPE:

                return this.getProjection();

            default:

                return super.getDynValue(name);

        }

    }

    @Override

    public void setDynValue(String name, Object value)

        throws DynFieldNotFoundException {

        switch(name) {

            case DataStore.METADATA_CRS:

                this.projection = (IProjection) value;

                break;

            case DataStore.METADATA_ENVELOPE:

                this.envelope = (Envelope) value;

                break;

            default:

                super.setDynValue(name, value);

                break;

        }

    }

    protected List<PageManager> getPageManagers() {

        this.autoOpen();

        return this.pageManagers;

    }

    protected IProjection getProjection() {

        this.autoOpen();

        return this.projection;

    }

    protected Envelope getEnvelope() {

        this.autoOpen();

        return this.envelope;

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        int[] bandDataTypes;

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

        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);

                thePageManagers.add(this.getPageManagers().get(band));

            }

        } else {

            bandDataTypes = this.getDataTypes();

            bandNoData = this.getNoDatas();

            thePageManagers = this.getPageManagers();

        }

        Buffer buffer = bufferManager.createBuffer(

                    this.getRows(), 

                    this.getColumns(), 

                    bandDataTypes, 

                    bandNoData,

                    this.getProjection(), 

                    this.getEnvelope(), 

                    thePageManagers

            );

        return buffer;    

    }

    @Override

    public abstract void open() throws OpenException;

    @Override

    public abstract int getBands();

    public abstract int getRows();

    public abstract int getColumns();

}