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.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.TreeMap;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.w3c.dom.Attr;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerManager;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderFactory;

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension;

/**

 * Represents a tiled image

 *

 * @author dmartinezizquierdo

 *

 */

public class FileTileCacheStructImage extends AbstractTileCacheStructImage {

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

    private static final int MAX_RECENT_ACCEDED_TILES_NUMBER = 50;

    private FilesystemServerExplorerProviderFactory factory;

    private String extension;

    private File tilesFolder;

    private IProjection crs;

    /**

     * @param folder

     * @param crs

     * @param innerProvider

     * @param query

     */

    public FileTileCacheStructImage(File folder, IProjection crs, RasterStoreProvider innerProvider, RasterQuery query) {

        super(innerProvider, query);

        this.crs = crs;

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        getTileStruct();

        // FIXME

        File tilePropertiesFile = new File(folder, "tileCacheStruct.xml");

        if (!tilePropertiesFile.exists()) {

            createTileCacheStructXMLFile(folder);

        }

        TreeMap<Integer, Double> pixelSizePerZoomLevel = new TreeMap<Integer, Double>();

        recentAccededTiles = new HashMap<String, Tile>();

        tilesFolder = new File(folder, "V" + File.separatorChar + "Z" + File.separatorChar + "T");

        if (!tilesFolder.exists()) {

            tilesFolder.mkdirs();

        }

        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

        DocumentBuilder dBuilder;

        try {

            dBuilder = dbFactory.newDocumentBuilder();

            Document doc = dBuilder.parse(tilePropertiesFile);

            doc.getDocumentElement().normalize();

            NodeList nList = doc.getElementsByTagName("TileCacheStruct");

            for (int temp = 0; temp < nList.getLength(); temp++) {

                Node nNode = nList.item(temp);

                if (nNode.getNodeType() == Node.ELEMENT_NODE) {

                    Element eElement = (Element) nNode;

                    NamedNodeMap tileSizeAttributes = eElement.getElementsByTagName("tileSize").item(0).getAttributes();

                    tileStruct.setRowsPerTile(Integer.valueOf(tileSizeAttributes.getNamedItem("rows").getNodeValue()));

                    tileStruct.setColumnsPerTile(Integer.valueOf(tileSizeAttributes.getNamedItem("columns").getNodeValue()));

                    NodeList elementsByTagName = eElement.getElementsByTagName("format");

                    tileStruct.setProviderName(elementsByTagName.item(0).getTextContent());

                    NodeList structExtentList = eElement.getElementsByTagName("structExtent");

                    if (structExtentList.getLength() > 0) {

                        Element structExtentNode = (Element) structExtentList.item(0);

                        if (structExtentNode != null) {

                            Double minX =

                                Double.valueOf(structExtentNode.getElementsByTagName("minX").item(0).getTextContent());

                            Double minY =

                                Double.valueOf(structExtentNode.getElementsByTagName("minY").item(0).getTextContent());

                            Double maxX =

                                Double.valueOf(structExtentNode.getElementsByTagName("maxX").item(0).getTextContent());

                            Double maxY =

                                Double.valueOf(structExtentNode.getElementsByTagName("maxY").item(0).getTextContent());

                            tileStruct.setEnvelope(geoManager.createEnvelope(minX, minY, maxX, maxY, SUBTYPES.GEOM2D));                        }

                    }

                    FilesystemServerExplorerManager explorerManager =

                        DALFileLocator.getFilesystemServerExplorerManager();

                    @SuppressWarnings("unchecked")

                    Iterator<Extension> it = explorerManager.getRegisteredProviders();

                    while (it.hasNext()) {

                        Extension ext = it.next();

                        FilesystemServerExplorerProviderFactory providerFactory;

                        try {

                            providerFactory = (FilesystemServerExplorerProviderFactory) ext.create();

                            if (providerFactory.getName().equalsIgnoreCase(tileStruct.getProviderName())) {

                                this.factory = providerFactory;

                                break;

                            }

                        } catch (Exception e) {

                            throw new RuntimeException(e);// FIXME !!!

                        }

                    }

                    NodeList levelsTag = eElement.getElementsByTagName("levels");

                    Element levels = (Element) levelsTag.item(0);

                    NodeList levelList = levels.getElementsByTagName("level");

                    for (int i = 0; i < levelList.getLength(); i++) {

                        Element level = (Element) levelList.item(i);

                        NamedNodeMap levelAttributes = level.getAttributes();

                        int zoomLevel = Integer.valueOf(levelAttributes.getNamedItem("index").getNodeValue());

                        double pixelSize = Double.valueOf(levelAttributes.getNamedItem("pixelSize").getNodeValue());

                        pixelSizePerZoomLevel.put(zoomLevel, pixelSize);

                    }

                    this.tileStruct.setPixelSizePerZoomLevel(pixelSizePerZoomLevel);

                }

            }

        } catch (Exception e) {

            throw new RuntimeException();

        }

    }

    /* (non-Javadoc)

     * @see org.gvsig.raster.tilecache.provider.ITileStructImage#fetchTile(int, int, int, int)

     */

    @Override

    public Band fetchTile(int bandNumber, int zoomLevel, int structRow, int structCol) throws CreateEnvelopeException,

        ValidateDataParametersException, CloneNotSupportedException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        String keyTile = composeKeyForRecentTiles(zoomLevel, structRow, structCol);

        Tile tile = recentAccededTiles.get(keyTile);

        if (tile != null) {

            // Devolver la banda del buffer del tile

            return tile.getBuffer().getBand(bandNumber);

        } else {

            // Cargar un tile nuevo

            Buffer rasterSet = null;

            RasterStore tileStore = null;

            RasterSet tileStoreRasterSet = null;

            try {

                tileStore = createTileStore(zoomLevel, structRow, structCol);

                tileStoreRasterSet = tileStore.getRasterSet();

                rasterSet = bufferManager.createBuffer(tileStoreRasterSet, false);

                if (recentAccededTiles.size() >= MAX_RECENT_ACCEDED_TILES_NUMBER) {

                    removeOlderTile();

                }

                recentAccededTiles.put(keyTile, new Tile(rasterSet, keyTile));

                Band band = rasterSet.getBand(bandNumber);

                ToolsLocator.getDisposableManager().bind(band);

                return band;

            } catch (DataException | BufferException e) {

                logger.warn("Can't fetch tile: zoomLevel = " + zoomLevel + ", tileRow = " + structRow

                    + ", tileColumn = " + structCol + ", band = " + bandNumber + ".", e);

                return null;

            } finally {

                DisposeUtils.dispose(tileStore);

                tileStore = null;

                DisposeUtils.dispose(tileStoreRasterSet);

                tileStoreRasterSet = null;

                DisposeUtils.dispose(rasterSet);

                rasterSet = null;

            }

        }

    }

    private RasterStore createTileStore(int zoomLevel, int structRow, int structCol)

        throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException,

        CloneNotSupportedException {

        File tileFile = null;

        File zoomFolder = new File(tilesFolder, String.valueOf(zoomLevel));

        if (!zoomFolder.exists()) {

            zoomFolder.mkdirs();

        }

        File firstColumnFolder = new File(zoomFolder, String.valueOf(structCol));

        if (!firstColumnFolder.exists()) {

            tileFile = requestTileFile(zoomLevel, structRow, structCol);

            this.extension = FilenameUtils.getExtension(tileFile.getAbsolutePath());

        }

        String rowBaseName = String.valueOf(structRow);

        if (this.extension == null) {

            File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory);

            for (int i = 0; i < providerAcceptedFiles.length; i++) {

                File providerAcceptedFile = providerAcceptedFiles[i];

                if (FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase(rowBaseName)) {

                    tileFile = providerAcceptedFile;

                }

            }

            if (tileFile == null || !tileFile.exists()) {

                tileFile = requestTileFile(zoomLevel, structRow, structCol);

            }

            this.extension = FilenameUtils.getExtension(tileFile.getAbsolutePath());

        } else {

            if (tileFile == null) {

                tileFile =

                    new File(firstColumnFolder.getAbsolutePath() + File.separatorChar + rowBaseName + "."

                        + this.extension);

            }

        }

        if (!tileFile.exists()) {

            tileFile = requestTileFile(zoomLevel, structRow, structCol);

        }

        RasterStore tileStore = null;

        DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices();

        DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(this.tileStruct.getProviderName());

        DynObject params = providerFactory.createParameters();

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

            params.setDynValue("file", tileFile);

        }

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

            params.setDynValue("crs", this.crs);

        }

        tileStore = (RasterStore) manager.openStore(this.tileStruct.getProviderName(), params);

        return tileStore;

    }

    private File requestTileFile(int zoomLevel, int structRow, int structCol) throws CreateEnvelopeException,

        CloneNotSupportedException, BufferException, ValidateDataParametersException, DataException {

        RasterQuery rasterQuery = (RasterQuery) this.query.clone();

        Double pixelSize = this.tileStruct.getPixelSizePerZoomLevel().get(zoomLevel);

        rasterQuery.setPixelSize(pixelSize);

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Envelope structExtent = this.tileStruct.getEnvelope();

        int rowsPerTile = this.tileStruct.getRowsPerTile();

        int columnsPerTile = this.tileStruct.getColumnsPerTile();

        double minX = structExtent.getMinimum(DIMENSIONS.X) + structCol * (pixelSize * columnsPerTile);

        double minY = structExtent.getMaximum(DIMENSIONS.Y) - ((structRow + 1) * (pixelSize * rowsPerTile));

        double maxX = minX + pixelSize * columnsPerTile;

        double maxY = minY + pixelSize * rowsPerTile;

        Envelope envelope = geomManager.createEnvelope(minX, minY, maxX, maxY, SUBTYPES.GEOM2D);

        Buffer buffer = null;

        Buffer clippedBuffer = null;

        Buffer interpolatedBuffer = null;

        File destFile = null;

        try {

            buffer = innerProvider.createBuffer(rasterQuery);

            clippedBuffer = buffer.clip(envelope);

            interpolatedBuffer =

                clippedBuffer.createInterpolated(

                    (int) (Math.round(clippedBuffer.getPixelSizeY() * clippedBuffer.getRows() / pixelSize)),

                    (int) (Math.round(clippedBuffer.getPixelSizeX() * clippedBuffer.getColumns() / pixelSize)),

                    Buffer.INTERPOLATION_NearestNeighbour, null);

            String providerName = "GTiff";

            String extension = "tif";

            DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices();

            DataServerExplorerParameters eparams;

            eparams = manager.createServerExplorerParameters("FilesystemExplorer");

            StringBuilder builder = new StringBuilder();

            builder.append(tilesFolder);

            builder.append(File.separator);

            builder.append(zoomLevel);

            builder.append(File.separator);

            builder.append(structCol);

            builder.append(File.separator);

            builder.append(structRow);

            builder.append(".");

            builder.append(extension);

            String path = builder.toString();

            destFile = new File(path);

            File parent = destFile.getParentFile();

            if (!parent.exists()) {

                parent.mkdirs();

            }

            eparams.setDynValue("initialpath", path);

            DataServerExplorer serverExplorer = manager.createServerExplorer(eparams);

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

            params.setDynValue("file", destFile);

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

            params.setDynValue("tfw", false);

            // FIXME: Ver de coger estos dos valores del inner provider para que

            // los tiles sean homog?neos con el raster original

            int bands = innerProvider.getBands();

            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", "MIN_IS_BLACK");

                break;

            }

            params.setBuffer(interpolatedBuffer);

            serverExplorer.add(providerName, params, true);

        } finally {

            DisposeUtils.dispose(buffer);

            DisposeUtils.dispose(clippedBuffer);

            DisposeUtils.dispose(interpolatedBuffer);

        }

        return destFile;

    }

    @Override

    protected void doDispose() throws BaseException {

        if (recentAccededTiles != null) {

            Set<Entry<String, Tile>> entrySet = recentAccededTiles.entrySet();

            for (Iterator<Entry<String, Tile>> iterator = entrySet.iterator(); iterator.hasNext();) {

                Entry<String, Tile> entry = (Entry<String, Tile>) iterator.next();

                DisposeUtils.dispose(entry.getValue());

            }

            recentAccededTiles.clear();

        }

        DisposeUtils.dispose(innerProvider);

        innerProvider = null;

        DisposeUtils.dispose((Disposable) tileStruct);

        tileStruct = null;

        query = null;

        factory = null;

        crs = null;

        colorInterpretation = null;

        legend = null;

        colorTable = null;

    }

    private void createTileCacheStructXMLFile(File folder) {

        TileStruct tileStructProvider = null;

        if (innerProvider != null && innerProvider instanceof TiledRasterStoreProvider) {

            tileStructProvider = ((TiledRasterStoreProvider) innerProvider).getTileStruct();

        }

        int tileSizeX = TileCacheLibrary.DEFAULT_TILEWIDTH;

        if(tileStructProvider!=null && tileStructProvider.getColumnsPerTile()!=0){

            tileSizeX = tileStructProvider.getColumnsPerTile();

        }

        int tileSizeY = TileCacheLibrary.DEFAULT_TILEHEIGHT;

        if(tileStructProvider!=null && tileStructProvider.getRowsPerTile()!=0){

            tileSizeY = tileStructProvider.getRowsPerTile();

        }

        File file = new File(folder, "tileCacheStruct.xml");

        if (!file.exists()) {

            Buffer auxBuffer = null;

            try {

                DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();

                DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

                // root elements

                Document doc = (Document) docBuilder.newDocument();

                Element rootElement = doc.createElement("TileCacheStruct");

                doc.appendChild(rootElement);

                // tileSize

                Element tileSize = doc.createElement("tileSize");

                rootElement.appendChild(tileSize);

                // tileSize Rows

                Attr rows = doc.createAttribute("rows");

                rows.setValue(String.valueOf(tileSizeY));

                tileSize.setAttributeNode(rows);

                // tileSize Columns

                Attr columns = doc.createAttribute("columns");

                columns.setValue(String.valueOf(tileSizeX));

                tileSize.setAttributeNode(columns);

                // format

                Element format = doc.createElement("format");

                if(tileStructProvider==null || StringUtils.isEmpty(tileStructProvider.getProviderName())){

                    format.setTextContent("GTiff");

                }

                rootElement.appendChild(format);

                // structExtent

                Element structExtent = doc.createElement("structExtent");

                rootElement.appendChild(structExtent);

                Envelope envelope = (Envelope) innerProvider.getDynValue(DataStore.METADATA_ENVELOPE);

                // structExtent minX

                Element minX = doc.createElement("minX");

                minX.setTextContent(String.valueOf(envelope.getMinimum(DIMENSIONS.X)));

                structExtent.appendChild(minX);

                // structExtent minY

                Element minY = doc.createElement("minY");

                minY.setTextContent(String.valueOf(envelope.getMinimum(DIMENSIONS.Y)));

                structExtent.appendChild(minY);

                // structExtent maxX

                Element maxX = doc.createElement("maxX");

                maxX.setTextContent(String.valueOf(envelope.getMaximum(DIMENSIONS.X)));

                structExtent.appendChild(maxX);

                // structExtent maxY

                Element maxY = doc.createElement("maxY");

                maxY.setTextContent(String.valueOf(envelope.getMaximum(DIMENSIONS.Y)));

                structExtent.appendChild(maxY);

                Element levels = doc.createElement("levels");

                rootElement.appendChild(levels);

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

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

                if (tileStructProvider==null || tileStructProvider.getPixelSizePerZoomLevel() == null) {

                    // FIXME: ?alguna otra forma de obtener el pixelSize del store completo?

                    auxBuffer = innerProvider.createBuffer(null);

                    int completeRows = auxBuffer.getRows();

                    int completeColumns = auxBuffer.getColumns();

                    double completePixelSizeX = auxBuffer.getPixelSizeX();

                    double completePixelSizeY = auxBuffer.getPixelSizeY();

                    int maximumLength = completeColumns;

                    int tileMaximumLength = tileSizeX;

                    double maximumPixelSize = completePixelSizeX;

                    if (completeRows * tileSizeY > completeColumns * tileSizeX) {

                        maximumLength = completeRows;

                        tileMaximumLength = tileSizeY;

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

                        appendZoomLevel(doc, levels, i, pixelSizes.get(zoomLevel));

                        i++;

                    }

                } else {

                    zoomLevels = tileStructProvider.getPixelSizePerZoomLevel();

                }

                for (Entry<Integer, Double> entry : zoomLevels.entrySet()) {

                    appendZoomLevel(doc, levels, entry.getKey(), entry.getValue());

                }

                // write the content into xml file

                DOMSource source = new DOMSource(doc);

                File parent = file.getParentFile();

                if (!parent.exists()) {

                    parent.mkdirs();

                }

                file.createNewFile();

                StreamResult result = new StreamResult(file.toURI().getPath());

                TransformerFactory transformerFactory = TransformerFactory.newInstance();

                Transformer transformer = transformerFactory.newTransformer();

                transformer.setOutputProperty(OutputKeys.INDENT, "yes");

                transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");

                transformer.transform(source, result);

            } catch (ParserConfigurationException | TransformerException | IOException | BufferException e) {

                logger.warn("Can't create tileCacheStruct.xml file", e);

            } finally {

                DisposeUtils.dispose(auxBuffer);

                auxBuffer = null;

            }

        }

    }

    /**

     * @param doc

     * @param rootElement

     * @param levels

     * @param zoomLevel

     * @param pixelSize

     */

    private void appendZoomLevel(Document doc, Element levels, int zoomLevel, double pixelSize) {

        Element level = doc.createElement("level");

        levels.appendChild(level);

        // level zoomLevel

        Attr index = doc.createAttribute("index");

        index.setValue(String.valueOf(zoomLevel));

        level.setAttributeNode(index);

        // level pixelSize

        Attr pxSize = doc.createAttribute("pixelSize");

        pxSize.setValue(String.valueOf(pixelSize));

        level.setAttributeNode(pxSize);

    }

    /* (non-Javadoc)

     * @see org.gvsig.raster.tilecache.provider.ITileStructImage#getTileStruct()

     */

    @Override

    public TileStruct getTileStruct() {

        if(this.tileStruct==null){

            this.tileStruct = new DefaultTileStruct();

        }

        return this.tileStruct;

    }

    public void forgetCache() {

        super.forgetCache();

        if(tilesFolder.exists() && tilesFolder.isDirectory()){

            File[] files = tilesFolder.listFiles();

            for(int i=0; i<files.length; i++){

                try {

                    FileUtils.forceDelete(files[i]);

                } catch (IOException e) {

                    logger.warn("Can't delete the file "+files[i].getAbsolutePath(), e);

                }

            }

        }

    }

}