Application: gvSIG desktop » gvSIG raster

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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.raster.tilecache.provider;

import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

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.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.CloseException;

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.api.BandAttributeDescriptor;

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

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

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

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

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

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

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

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.spi.DataStoreProviderServices;

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

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

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.BufferManager;

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

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

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

import org.gvsig.tools.ToolsLocator;

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.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

/**

 * Provider for Tile Cache

 *

 * @author dmartinezizquierdo

 *

 */

public class TileCacheStoreProvider extends AbstractRasterStoreProvider implements RasterCacheStoreProvider,

    ResourceConsumer {

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

    public static String NAME = "TileCache";

    public static String DESCRIPTION = "Tile cache provider";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private ResourceProvider resource;

    private final SimpleTaskStatus taskStatus;

    private TileStructImage tileStructImage = null;

    private Envelope envelope = null;

    private IProjection projection = null;

    Map<Integer,List<PageManager>> pageManagersPerZoomLevel = null;

//    private RasterStore innerStore;

    private RasterStoreProvider innerProvider;

    private int bandsNumber;

    protected static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        if (manager.getDefinition(METADATA_DEFINITION_NAME) == null) {

            manager.addDefinition(METADATA_DEFINITION_NAME,

                TileCacheStoreProviderParameters.class.getResourceAsStream("TileCacheMetadata.xml"),

                TileCacheStoreProviderParameters.class.getClassLoader());

        }

    }

    /**

     * @param params

     * @param storeServices

     * @throws InitializeException

     */

    public TileCacheStoreProvider(TileCacheStoreProviderParameters params, DataStoreProviderServices storeServices)

        throws InitializeException {

        super(params, storeServices, FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME));

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("TileCache");

        this.init(params, storeServices);

    }

    protected TileCacheStoreProvider(TileCacheStoreProviderParameters params, DataStoreProviderServices storeServices,

        DynObject metadata) throws InitializeException {

        super(params, storeServices, metadata);

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("TileCache");

        this.init(params, storeServices);

    }

    protected void init(TileCacheStoreProviderParameters params,

        DataStoreProviderServices storeServices) throws InitializeException {

//        store = (RasterStore) storeServices.getStore();

        bandsNumber = ((RasterStore)storeServices).getBands();

        if (params == null) {

            throw new InitializeException(

                new NullPointerException("params is null"));

        }

        this.projection=params.getCRS();

//      String rcacheDir = Launcher.getAppHomeDir() + File.separator + "gvsig_rcache";

//      Envelope storeEnvelope = store.getEnvelope();

//      store.getRasterSet().getPixelSizeX();

      File cacheFolder = (File) params.getDynValue(TileCacheStoreProviderParameters.TILECACHE_CACHEFOLDER_PARAMTER_NAME);

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { cacheFolder.getAbsolutePath() }

        );

        resource.addConsumer(this);

    }

    private TileCacheStoreProviderParameters getTileCacheParameters() {

        return (TileCacheStoreProviderParameters) this.getParameters();

    }

    @Override

    public BandDescriptor getBandDescriptor(int band) {

        if (band > this.getBands()) {

            throw new IllegalArgumentException("Invalid band");

        }

        return getStoreServices().createBandDescriptor(band, new ArrayList<BandAttributeDescriptor>());

    }

    @Override

    public int getBands() {

        return bandsNumber;

    }

    @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) {

        List<BandQuery> bands;

        bands = rasterQuery.getBands();

        bandDataTypes = new int[bandsNumber];

        bandNoData = new NoData[bandsNumber];

        int zoomLevel = tileStructImage.getZoomLvlForPixelSize(rasterQuery.getPixelSize());

        List<PageManager> pageManagersInZoom;

        int[] tileStructDataTypes;

        try {

            pageManagersInZoom = getPageManagersInZoom(zoomLevel);

            tileStructDataTypes = tileStructImage.getDataTypes();

        } catch (ValidateDataParametersException | CreateEnvelopeException | DataException | CloneNotSupportedException e) {

            throw new BufferException(e);

        }

        try {

            for(int i = 0; i<tileStructImage.getBandNumber(); i++){

                bandDataTypes[i] = tileStructDataTypes[i];

                bandNoData[i] = null;

                pageManagers.add(pageManagersInZoom.get(i));

            }

        } catch (ValidateDataParametersException | CreateEnvelopeException | DataException | CloneNotSupportedException e) {

            throw new BufferException(e);

        }

//        for (BandQuery bandQuery : bands) {

//            // FIXME:

//            int band = bandQuery.getBand();

//            bandDataTypes[band] = tileStructDataTypes[band];

//            bandNoData[band] = null;

//            pageManagers.add(pageManagersInZoom.get(band));

//        }

        // } else {

        // int bands = getBands();

        // bandDataTypes = new int[bands];

        // bandNoData = new NoData[bands];

        // for (int i = 0; i < bands; i++) {

        // bandDataTypes[i] = tileStructImage.getDataTypes()[i];

        // bandNoData[i] = null;

        // pageManagers.add(new TileCacheBandPageManager(tileStructImage,

        // rasterQuery.getPixelSize(), i));

        // }

        // }

        envelope = tileStructImage.getEnvelope();

        Buffer buffer =

            bufferManager.createBuffer(tileStructImage.getRows(zoomLevel), tileStructImage.getColumns(zoomLevel),

                bandDataTypes, bandNoData, projection, envelope, pageManagers);

        return buffer;

    }

    private List<PageManager> getPageManagersInZoom(int zoomLevel) throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {

        List<PageManager> pageManagersInZoom = this.pageManagersPerZoomLevel.get(zoomLevel);

        if (pageManagersInZoom == null) {

            pageManagersInZoom = new ArrayList<PageManager>();

            for (int i = 0; i < tileStructImage.getBandNumber(); i++) {

                pageManagersInZoom.add(new TileCacheBandPageManager(tileStructImage, zoomLevel, i));

            }

            this.pageManagersPerZoomLevel.put(zoomLevel, pageManagersInZoom);

        }

        return pageManagersInZoom;

    }

    @Override

    public BandInfo getBandInfo(int band) {

        // FIXME

        return null;// tileStructImage.getBandInfo(band);

    }

    @Override

    public DataServerExplorer getExplorer() throws ReadException, ValidateDataParametersException {

        // DataManager manager = DALLocator.getDataManager();

        // FilesystemServerExplorerParameters params;

        // try {

        // params = (FilesystemServerExplorerParameters) manager

        // .createServerExplorerParameters(FilesystemServerExplorer.NAME);

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

        // return

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

        // } catch (DataException e) {

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

        // } catch (ValidateDataParametersException e) {

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

        // }

        // FIXME

        return null;

    }

    public void open() throws OpenException {

        if (this.tileStructImage != null) {

            return;

        }

//        openEver();

    }

//    private void openEver() throws OpenException {

//        try {

//

//            getResource().execute(new ResourceAction() {

//

//                public Object run() throws Exception {

//

//                    try {

//                        File folder = (File) resource.get();

//                        resource.notifyOpen();

//

//                        // FIXME

//                        tileStructImage = new TileStructImage(folder, getTileCacheParameters().getCRS(), null);

//                        pageManagersPerZoomLevel = new HashMap<Integer, List<PageManager>>();

//

//                        // if (getTileCacheParameters().getWldParams()!=null){

//                        // envelope=createWLDEnvelope(getTileCacheParameters().getWldParams());

//                        // }else{

//                        // envelope =

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

//                        // 0,

//                        // tileStructImage.getColumns(),

//                        // tileStructImage.getRows(), Geometry.SUBTYPES.GEOM2D);

//                        // }

//

//                        resource.notifyClose();

//

//                        resource.setData(tileStructImage);

//                    } finally {

//                        // TODO

//                    }

//                    return null;

//                }

//

//            });

//        } catch (Exception e) {

//            this.tileStructImage = null;

//            try {

//                throw new OpenException(resource.getName(), e);

//            } catch (AccessResourceException e1) {

//                throw new OpenException(getProviderName(), e);

//            }

//        } finally {

//            this.taskStatus.remove();

//        }

//    }

    // private 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=tileStructImage.getRows()*pixelSizeY;

    // double width=tileStructImage.getColumns()*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 = this.getTileCacheParameters().getCRS();

            if (pro != null) {

                return pro;

            }

        }

        return super.getDynValue(name);

    }

    @Override

    public void close() throws CloseException {

        this.tileStructImage = null;

    }

    @Override

    public ResourceProvider getResource() {

        return this.resource;

    }

    @Override

    public Object getSourceId() {

        return this.getTileCacheParameters().getCacheFolder();

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public String getName() {

        String name = this.getTileCacheParameters().getCacheFolder().getName();

        return name; // FilenameUtils.getBaseName(name);

    }

    @Override

    public String getFullName() {

        return this.getTileCacheParameters().getCacheFolder().getAbsolutePath();

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    @Override

    /*

     * (non-Javadoc)

     *

     * @see

     * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.

     * gvsig.fmap.dal.resource.spi.ResourceProvider)

     */

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(DataStoreNotification.RESOURCE_CHANGED, resource);

    }

    @Override

    /*

     * (non-Javadoc)

     *

     * @see

     * org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider#doDispose

     * ()

     */

    protected void doDispose() throws BaseException {

        super.doDispose();

        resource.removeConsumer(this);

        if(this.tileStructImage!=null){

            DisposeUtils.dispose(tileStructImage);

            this.tileStructImage = null;

        }

    }

    /**

     * @return TileStructImage

     */

    public TileStructImage getTileStructImage() {

        return tileStructImage;

    }

    @Override

    public void apply(RasterStoreProvider provider, IProjection crs, RasterQuery query) throws DataException {

        this.innerProvider = provider;

        pageManagersPerZoomLevel = new HashMap<Integer, List<PageManager>>();

        this.tileStructImage =

            new TileStructImage(((FileResource)resource).getFile(), crs, provider, query);

    }

    @Override

    public RasterStoreProvider getInnerProvider() {

        return innerProvider;

    }

}