Application: gvSIG desktop » gvSIG raster

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2018 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.wmts.provider;

import java.awt.Image;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.SortedSet;

import java.util.TreeSet;

import java.util.Map.Entry;

import javax.imageio.ImageIO;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.crs.CRSFactory;

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

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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.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.raster.wmts.ogc.WMTSClient;

import org.gvsig.raster.wmts.ogc.WMTSOGCLocator;

import org.gvsig.raster.wmts.ogc.WMTSStatus;

import org.gvsig.raster.wmts.ogc.exception.WMTSException;

import org.gvsig.raster.wmts.ogc.struct.WMTSLayer;

import org.gvsig.raster.wmts.ogc.struct.WMTSStyle;

import org.gvsig.raster.wmts.ogc.struct.WMTSTileMatrix;

import org.gvsig.raster.wmts.ogc.struct.WMTSTileMatrixSet;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.tools.locator.LocatorException;

/**

 * @author fdiaz

 *

 */

public class WMTSRasterProvider extends AbstractRasterStoreProvider {

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

    public static String NAME = "WMTS";

    public static String DESCRIPTION = "WMTS Raster Provider";

    public static final String METADATA_DEFINITION_NAME = "WMTS";

    public static final int DEFAULT_BUFFER_SIZE = 256;

    public static final int DEFAULT_MAX_ZOOM_LEVEL = 22;

    // WMTS Parameters

    private WMTSClient wmtsClient;

    private WMTSStatus wmtsStatus;

    private String layerName;

    private Envelope envelope = null;

    private IProjection projection = null;

    private WMTSImage image;

    private TileStruct tileStruct = null;

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

    private Map<Integer, WMTSTileMatrix> tileMatrixPerZoomLevel = null;

    private int columnsPerTile;

    private int rowsPerTile;

    private int maxZoomLevel;

    protected WMTSRasterProvider(DataStoreParameters params, DataStoreProviderServices storeServices) throws InitializeException {

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

        initParams();

    }

    private void initParams() throws InitializeException {

        WMTSRasterProviderParameters parameters = (WMTSRasterProviderParameters) getParameters();

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

//        this.projection = getProjection();

//        wmtsClient = getWMTSClient();

//        wmtsStatus = getWMTSStatus();

        envelope = getEnvelope();

        maxZoomLevel = DEFAULT_MAX_ZOOM_LEVEL;

        //PRUEBA

//        tileStruct = getTileStruct();

    }

    protected WMTSStatus getWMTSStatus() throws InitializeException {

        if( this.wmtsStatus == null ){

            wmtsStatus = getWMTSClient().createStatus();

            WMTSLayer wmtsLayer = getWMTSClient().getLayer(getLayerName());

            wmtsStatus.setLayer(wmtsLayer.getIdentifier());

            wmtsStatus.setStyle((String)getParameters().getDynValue(WMTSRasterProviderParameters.WMTS_STYLE_PARAMETER_NAME));

            wmtsStatus.setFormat((String) getParameters().getDynValue(WMTSRasterProviderParameters.WMTS_FORMAT_PARAMETER_NAME));

            wmtsStatus.setInfoFormat((String) getParameters().getDynValue(WMTSRasterProviderParameters.WMTS_INFO_FORMAT_PARAMETER_NAME));

            wmtsStatus.setSrs(getProjection().getAbrev());

            wmtsStatus.setTileMatrixSet(getTileMatrixSet().getIdentifier());

        }

        // TODO Auto-generated method stub

        return this.wmtsStatus;

    }

    private String getLayerName() {

        if( this.layerName == null){

            this.layerName = (String) getParameters().getDynValue(WMTSRasterProviderParameters.WMTS_LAYER_PARAMETER_NAME);

        }

        return this.layerName;

    }

    protected static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

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

            manager.addDefinition(METADATA_DEFINITION_NAME,

                WMTSRasterProviderParameters.class.getResourceAsStream("WMTSRasterMetadata.xml"),

                WMTSRasterProviderParameters.class.getClassLoader());

        }

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        try {

            BufferManager bufferManager = BufferLocator.getBufferManager();

            int[] bandDataTypes;

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

            NoData[] bandNoData;

            Envelope envelope = getTileStruct().getEnvelope();

            double pixelSize = rasterQuery.getPixelSize();

            int zoomLevel;

            if (pixelSize == 0) {

                zoomLevel = 0;

            } else {

                zoomLevel = getZoomLvlForPixelSize(pixelSize);

            }

                if (!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);

                        try {

                            pageManagers.add(getPageManagersInZoom(zoomLevel).get(band));

                        } catch (ValidateDataParametersException | CreateEnvelopeException | DataException

                            | CloneNotSupportedException e) {

                            // TODO Auto-generated catch block

                            throw new BufferException(e);

                        }

                    }

                } else {

                    int bands = getBands();

                    bandDataTypes = new int[bands];

                    bandNoData = new NoData[bands];

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

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

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

                        try {

                            pageManagers.add(getPageManagersInZoom(zoomLevel).get(i));

                        } catch (ValidateDataParametersException | CreateEnvelopeException | DataException

                            | CloneNotSupportedException e) {

                            throw new BufferException(e);

                        }

                    }

                }

            Buffer buffer =

                bufferManager.createBuffer(getRows(zoomLevel), getColumns(zoomLevel), bandDataTypes, bandNoData,

                    projection, envelope, pageManagers);

            if(rasterQuery.getClip()!=null){

                Buffer completeBuffer = buffer;

                envelope  = rasterQuery.getClip();

                buffer = bufferManager.createClippedBuffer(completeBuffer, envelope);

                DisposeUtils.dispose(completeBuffer);

            }

            return buffer;

        } catch (Exception e) {

            throw new BufferException(e);

        }

    }

    @Override

    public BandDescriptorServices getBandDescriptor(int band) {

        BandDescriptorServices descriptor = super.getBandDescriptor(band);

      switch (band) {

      case 0:

          descriptor.setName("RED");

          descriptor.setDescription("RED");

          descriptor.setDataType(BufferManager.TYPE_BYTE);

      case 1:

          descriptor.setName("GREEN");

          descriptor.setDescription("GREEN");

          descriptor.setDataType(BufferManager.TYPE_BYTE);

      case 2:

          descriptor.setName("BLUE");

          descriptor.setDescription("BLUE");

          descriptor.setDataType(BufferManager.TYPE_BYTE);

      case 3:

          descriptor.setName("ALPHA");

          descriptor.setDescription("ALPHA");

          descriptor.setDataType(BufferManager.TYPE_BYTE);

      }

      return descriptor;

    }

    @Override

    public int getBands() {

        return 4;

    }

    @Override

    public DataServerExplorer getExplorer() throws ReadException, ValidateDataParametersException {

        DataManager manager = DALLocator.getDataManager();

        WMTSRasterServerExplorerParameters params;

        try {

            params =

                (WMTSRasterServerExplorerParameters) manager

                    .createServerExplorerParameters(WMTSRasterServerExplorer.NAME);

            params.setService(((WMTSRasterProviderParameters) getParameters()).getService());

//            params.setXYAxisOrder(((WMTSRasterProviderParameters) getParameters()).getXYAxisOrder());

            return manager.openServerExplorer(WMTSRasterServerExplorer.NAME, (DataServerExplorerParameters) params);

        } catch (Exception e) {

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

        }

    }

    @Override

    public void open() throws OpenException {

        for(int i=0; i<getBands(); i++){

            this.getBandDescriptor(i).setDataType(DataTypes.BYTE);

        }

    }

    @Override

    public ResourceProvider getResource() {

        return null;

    }

    @Override

    public Object getSourceId() {

        return getParameters().getDynValue(WMTSRasterProviderParameters.WMTS_SERVICE_PARAMETER_NAME);

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public String getName() { //lista de capas

        @SuppressWarnings("unchecked")

        String layerName = (String) getParameters().getDynValue("layer");

//        StringBuilder builder = new StringBuilder();

//        for (int i = 0; i < layers.size(); i++) {

//            if (i != 0) {

//                builder.append(",");

//            }

//            builder.append(layers.get(i));

//        }

        return layerName;

    }

    @Override

    public String getFullName() { // host:port - lista de capas

        StringBuilder builder = new StringBuilder();

        URL service = (URL)this.getParameters().getDynValue(WMTSRasterProviderParameters.WMTS_SERVICE_PARAMETER_NAME);

        builder.append(service.getHost());

        int port = service.getPort();

        if(port < 0){

            int defaultPort = service.getDefaultPort();

            if(defaultPort>=0){

                builder.append(":");

                builder.append(service.getDefaultPort());

            }

        } else {

            builder.append(":");

            builder.append(port);

        }

        builder.append(" - ");

        builder.append(getName());

        return builder.toString();

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

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

            return this.getParameters().getDynValue(name);

        }

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

            try {

                return this.getEnvelope();

            } catch (InitializeException e) {

                throw new DynFieldNotFoundException(name, this.getClass().getName());

            }

        }

        return super.getDynValue(name);

    }

    private Envelope getEnvelope() throws InitializeException {

        if(this.envelope == null){

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            try {

                WMTSLayer wmtsLayer = getWMTSClient().getLayer(getLayerName());

                Rectangle2D rectangle2d = wmtsLayer.getWGS84BBox().toRectangle2D();

                Envelope envelopeWGS84 = geomManager.createEnvelope(rectangle2d.getMinX(), rectangle2d.getMinY(), rectangle2d.getMaxX(), rectangle2d.getMaxY(), Geometry.SUBTYPES.GEOM2D);

                ICoordTrans ct = CRSFactory.getCRS("EPSG:4326").getCT(getProjection());

                this.envelope = envelopeWGS84.convert(ct);

//                Rectangle2D extent = wmtsLayer.getWGS84BBoxTransformed(getProjection().getAbrev());

//

//                this.envelope =

//                    geomManager.createEnvelope(extent.getMinX(), extent.getMinY(), extent.getMaxX(), extent.getMaxY(),

//                        SUBTYPES.GEOM2D);

            } catch (CreateEnvelopeException e) {

                throw new InitializeException("Can't create envelope.", e);

            }

        }

        return this.envelope;

    }

    @Override

    public TileStruct getTileStruct() {

        if (tileStruct == null) {

            /*

            StringBuilder builder = new StringBuilder();

            builder.append("\n");

            builder.append("****************** LAYER ************************");

            builder.append("\n");

            builder.append("projection = ");

            builder.append(projection.getAbrev());

            builder.append("\n");

            WMTSLayer layer = wmtsClient.getLayer(wmtsStatus.getLayer());

            String layerAbstract = layer.getAbstract();

            builder.append("layerAbstract = ");

            builder.append(layerAbstract);

            builder.append("\n");

            String layerIdentifier = layer.getIdentifier();

            builder.append("layerIdentifier = ");

            builder.append(layerIdentifier);

            builder.append("\n");

            String layerTitle = layer.getTitle();

            builder.append("layerTitle = ");

            builder.append(layerTitle);

            builder.append("\n");

            WMTSBoundingBox layerBbox = layer.getBBox();

            builder.append("layerBbox = ");

            if (layerBbox != null) {

                builder.append(layerBbox.getLowerCorner()[0]);

                builder.append(", ");

                builder.append(layerBbox.getLowerCorner()[1]);

                builder.append(" - ");

                builder.append(layerBbox.getUpperCorner()[0]);

                builder.append(", ");

                builder.append(layerBbox.getUpperCorner()[1]);

            } else {

                builder.append("null");

            }

            builder.append("\n");

            WMTSBoundingBox layerWGS84BBox = layer.getWGS84BBox();

            builder.append("layerWGS84BBox = ");

            if (layerWGS84BBox != null) {

                builder.append(layerWGS84BBox.getLowerCorner()[0]);

                builder.append(", ");

                builder.append(layerWGS84BBox.getLowerCorner()[1]);

                builder.append(" - ");

                builder.append(layerWGS84BBox.getUpperCorner()[0]);

                builder.append(", ");

                builder.append(layerWGS84BBox.getUpperCorner()[1]);

            } else {

                builder.append("null");

            }

            builder.append("\n");

            Rectangle2D layerWGS84BBoxProjected = layer.getWGS84BBoxTransformed(projection.getAbrev());

            builder.append("layerWGS84BBoxProjected = ");

            if (layerWGS84BBoxProjected != null) {

                builder.append(layerWGS84BBoxProjected.getMinX());

                builder.append(", ");

                builder.append(layerWGS84BBoxProjected.getMinY());

                builder.append(" - ");

                builder.append(layerWGS84BBoxProjected.getMaxX());

                builder.append(", ");

                builder.append(layerWGS84BBoxProjected.getMaxY());

            } else {

                builder.append("null");

            }

            builder.append("\n");

            List<WMTSTileMatrixSet> matrixSetsList = wmtsClient.getTileMatrixSet();

            builder.append("\n");

            builder.append("############ TILE MATRIX SET ITERATOR ###########");

            builder.append("\n");

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

                builder.append("================ MATRIX SET =====================");

                builder.append("\n");

                WMTSTileMatrixSet wmtsTileMatrixSet = (WMTSTileMatrixSet) iterator.next();

                String identifier = wmtsTileMatrixSet.getIdentifier();

                builder.append("wmtsTileMatrixSet.getIdentifier() = ");

                builder.append(identifier);

                builder.append("\n");

                int layerInitialLevel = layer.getInitialLevel(identifier);

                builder.append("*** layerInitialLevel = ");

                builder.append(layerInitialLevel);

                builder.append("\n");

                String wellKnownScaleSet = wmtsTileMatrixSet.getWellKnownScaleSet();

                builder.append("wmtsTileMatrixSet.getWellKnownScaleSet() = ");

                builder.append(wellKnownScaleSet);

                builder.append("\n");

                WMTSBoundingBox bounding = wmtsTileMatrixSet.getBoundingBox();

                builder.append("wmtsTileMatrixSet.getBoundingBox() = ");

                builder.append(bounding.getLowerCorner()[0]);

                builder.append(", ");

                builder.append(bounding.getLowerCorner()[1]);

                builder.append(" - ");

                builder.append(bounding.getUpperCorner()[0]);

                builder.append(", ");

                builder.append(bounding.getUpperCorner()[1]);

                builder.append("\n");

                String supportedCRS = wmtsTileMatrixSet.getSupportedCRS();

                builder.append("wmtsTileMatrixSet.getSupportedCRS() = ");

                builder.append(supportedCRS);

                builder.append("\n");

                List<WMTSTileMatrix> tileMatrix = wmtsTileMatrixSet.getTileMatrix();

                builder.append("???????????????? TILE MATRIX ????????????????????");

                builder.append("\n");

                for (Iterator iterator2 = tileMatrix.iterator(); iterator2.hasNext();) {

                    WMTSTileMatrix wmtsTileMatrix = (WMTSTileMatrix) iterator2.next();

                    String ident = wmtsTileMatrix.getIdentifier(); // 0 ?tal vez el zoom level?  parece que s?

                    builder.append("ident = ");

                    builder.append(ident);

                    builder.append("\n");

                    Rectangle2D bboxTileMatrixSet = wmtsTileMatrix.getBBoxTileMatrixSet(); // null

                    builder.append("bboxTileMatrixSet = ");

                    if (bboxTileMatrixSet != null) {

                        builder.append(bboxTileMatrixSet.getMinX());

                        builder.append(", ");

                        builder.append(bboxTileMatrixSet.getMinY());

                        builder.append(" - ");

                        builder.append(bboxTileMatrixSet.getMaxX());

                        builder.append(", ");

                        builder.append(bboxTileMatrixSet.getMaxY());

                    } else {

                        builder.append("null");

                    }

                    builder.append("\n");

                    double heightWCTile = wmtsTileMatrix.getHeightWCTile(false);

                    builder.append("heightWCTile = ");

                    builder.append(heightWCTile);

                    builder.append("\n");

                    double widthWCTile = wmtsTileMatrix.getWidthWCTile(false);

                    builder.append("widthWCTile = ");

                    builder.append(widthWCTile);

                    builder.append("\n");

                    double heightWCProjected = wmtsTileMatrix.getHeightWCTile(true);

                    builder.append("heightWCTileProjected [CHUNGO] = ");

                    builder.append(heightWCProjected);

                    builder.append("\n");

                    double widthWCProjected = wmtsTileMatrix.getWidthWCTile(true);

                    builder.append("widthWCTileProjected  [CHUNGO] = ");

                    builder.append(widthWCProjected);

                    builder.append("\n");

                    long matrixHeight = wmtsTileMatrix.getMatrixHeight();

                    builder.append("matrixHeight = ");

                    builder.append(matrixHeight);

                    builder.append("\n");

                    long matrixWidth = wmtsTileMatrix.getMatrixWidth();

                    builder.append("matrixWidth = ");

                    builder.append(matrixWidth);

                    builder.append("\n");

                    double scaleDenominator = wmtsTileMatrix.getScaleDenominator(); // 2.79541132014358E8

                                                                                    // puede ser el pixelSize

                    builder.append("scaleDenominator = ");

                    builder.append(scaleDenominator);

                    builder.append("\n");

                    int tileHeight = wmtsTileMatrix.getTileHeight(); // ??? rows in tile

                    builder.append("tileHeight = ");

                    builder.append(tileHeight);

                    builder.append("\n");

                    int tileWidth = wmtsTileMatrix.getTileWidth(); // ??? columns in tile

                    builder.append("tileWidth = ");

                    builder.append(tileWidth);

                    builder.append("\n");

                    double[] topLeftCorner = wmtsTileMatrix.getTopLeftCorner();

                    builder.append("topLeftCorner = ");

                    builder.append(topLeftCorner[0]);

                    builder.append(", ");

                    builder.append(topLeftCorner[1]);

                    builder.append("\n");

                    builder.append("-------------------------------------------------");

                    builder.append("\n");

                }

                builder.append("=================================================");

                builder.append("\n");

            }

            builder.append("#################################################");

            builder.append("\n");

            logger.info(builder.toString());

            */

            autoOpen();

            try {

                this.tileStruct = new DefaultTileStruct();

                this.columnsPerTile = DEFAULT_BUFFER_SIZE;

                this.rowsPerTile = DEFAULT_BUFFER_SIZE;

                this.tileStruct.setEnvelope(getEnvelope());

                tileMatrixPerZoomLevel = new HashMap<Integer, WMTSTileMatrix>();

                WMTSTileMatrixSet matrixSet = getTileMatrixSet();

                HashMap<Integer, Integer> tileWidthsCounter = new HashMap<Integer, Integer>();

                HashMap<Integer, Integer> tileHeightsCounter = new HashMap<Integer, Integer>();

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

                int zoomLevel = 0;

                if(matrixSet!=null){

                    List<WMTSTileMatrix> tileMatrixList = matrixSet.getTileMatrix();

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

                        WMTSTileMatrix wmtsTileMatrix = (WMTSTileMatrix) iterator.next();

                        long levelColumns = wmtsTileMatrix.getMatrixWidth()*wmtsTileMatrix.getTileWidth();

                        double levelWidth = wmtsTileMatrix.getMatrixWidth()*wmtsTileMatrix.getWidthWCTile(getProjection().isProjected());

                        double pixelSize = levelWidth/levelColumns;

                        zoomLevels.put(zoomLevel, pixelSize);

                        tileMatrixPerZoomLevel.put(zoomLevel, wmtsTileMatrix);

                        // Aprovechamos el bucle para contar los distintos

                        // valores que el servidor tiene para el tama?o de los

                        // tiles en cada nivel de zoom

                        int tileWidth = wmtsTileMatrix.getTileWidth();

                        if(!tileWidthsCounter.containsKey(tileWidth)){

                            tileWidthsCounter.put(tileWidth, 1);

                        } else {

                            tileWidthsCounter.put(tileWidth, tileWidthsCounter.get(tileWidth)+1);

                        }

                        int tileHeight = wmtsTileMatrix.getTileHeight();

                        if(!tileHeightsCounter.containsKey(tileHeight)){

                            tileHeightsCounter.put(tileHeight, 1);

                        } else {

                            tileHeightsCounter.put(tileHeight, tileHeightsCounter.get(tileHeight)+1);

                        }

                        maxZoomLevel = zoomLevel;

                        zoomLevel++;

                    }

                }

                //seleccionamos los m?s usados

                Integer aux = tileWidthsCounter.get(columnsPerTile);

                if(aux==null){

                    aux = 0;

                }

                Iterator<Entry<Integer, Integer>> it = tileWidthsCounter.entrySet().iterator();

                while (it.hasNext()) {

                    Entry<Integer, Integer> entry = it.next();

                    if(entry.getValue()>=aux){

                        aux = entry.getValue();

                        columnsPerTile = entry.getKey();

                    }

                }

                aux = tileHeightsCounter.get(rowsPerTile);

                if(aux==null){

                    aux = 0;

                }

                Iterator<Entry<Integer, Integer>> it2 = tileWidthsCounter.entrySet().iterator();

                while (it2.hasNext()) {

                    Entry<Integer, Integer> entry = it2.next();

                    if(entry.getValue()>=aux){

                        aux = entry.getValue();

                        rowsPerTile = entry.getKey();

                    }

                }

                //y los asignamos

                this.tileStruct.setColumnsPerTile(columnsPerTile);

                this.tileStruct.setRowsPerTile(rowsPerTile);

                //

                this.tileStruct.setPixelSizePerZoomLevel(zoomLevels);

            } catch (LocatorException | InitializeException e) {

                logger.warn("Can't create world extent of GoogleMaps", e);

            }

        }

        return this.tileStruct;

    }

    /**

     * @return

     * @throws InitializeException

     */

    private WMTSTileMatrixSet getTileMatrixSet() throws InitializeException {

        WMTSTileMatrixSet matrixSet = null;

        List<WMTSTileMatrixSet> matrixSets = wmtsClient.getTileMatrixSet();

        for (Iterator<WMTSTileMatrixSet> iterator = matrixSets.iterator(); iterator.hasNext();) {

            WMTSTileMatrixSet wmtsTileMatrixSet = (WMTSTileMatrixSet) iterator.next();

            String supportedCrs = wmtsTileMatrixSet.getSupportedCRS();

            IProjection supportedProjection = null;

            try {

                supportedProjection = CRSFactory.getCRS(supportedCrs);

                if(supportedProjection==null){

                    continue;

                }

            } catch (Exception e) {

                continue;

            }

            if ( supportedProjection.equals(getProjection()) ){

                matrixSet = wmtsTileMatrixSet;

                break;

            }

        }

        return matrixSet;

    }

    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 < getBands(); i++) {

                //FIXME el getTileStruct no sirve para este bandTileManager

                pageManagersInZoom.add(new WMTSBandTileManager(getTileStruct(), this.getWMTSImage(), zoomLevel, i, this));

            }

            this.pageManagersPerZoomLevel.put(zoomLevel, pageManagersInZoom);

        }

        return pageManagersInZoom;

    }

    /**

     * @param zoomLevel

     * @return rows per zoom level

     */

    public int getRows(int zoomLevel) {

        return (int) (Math.round(getTileStruct().getEnvelope().getLength(DIMENSIONS.Y) / this.getTileStruct().getPixelSizePerZoomLevel().get(zoomLevel)));

    }

    /**

     * @param zoomLevel

     * @return columns per zoom level

     */

    public int getColumns(int zoomLevel) {

        return (int) (Math.round(getTileStruct().getEnvelope().getLength(DIMENSIONS.X) / this.getTileStruct().getPixelSizePerZoomLevel().get(zoomLevel)));

    }

    /**

     * @param pixelSize

     * @return The appropriate zoom level for the pizelSize

     */

    private int getZoomLvlForPixelSize(double pixelSize) {

        //FIXME: Elegir el c?digo id?neo

        // Este trozo de c?digo selecciona un zoom superior con lo que,

        // al hacer la interpolaci?n se generar?n p?xeles m?s gordos

        int zoom = 0;

        Map<Integer, Double> pixelSizePerZoomLevel = tileStruct.getPixelSizePerZoomLevel();

        SortedSet<Integer> keySet = new TreeSet<>(Collections.reverseOrder());

        keySet.addAll(pixelSizePerZoomLevel.keySet());

        Iterator<Integer> iterator = keySet.iterator();

        while(iterator.hasNext()){

            zoom = iterator.next();

            double levelPixelSize = pixelSizePerZoomLevel.get(zoom);

            if (pixelSize <= levelPixelSize) {

                return zoom;

            }

        }

        return zoom;

        // Este trozo de c?digo selecciona un zoom inferior con lo que,

        // al hacer la interpolaci?n se perder?n p?xeles

        // repercutiendo en la legibilidad de las leyendas

        /*

        int zoom = 0;

        Map<Integer, Double> pixelSizePerZoomLevel = getTileStruct().getPixelSizePerZoomLevel();

        for (int i : pixelSizePerZoomLevel.keySet()) {

            zoom = i;

            double levelPixelSize = pixelSizePerZoomLevel.get(zoom);

            if (pixelSize >= levelPixelSize) {

                return zoom;

            }

        }

        return zoom;

        */

    }

    private WMTSImage getWMTSImage() {

        if(this.image == null){

            this.image = new WMTSImage(getTileStruct(), this.tileMatrixPerZoomLevel, this);

        }

        return this.image;

    }

    protected IProjection getProjection(){

        if(this.projection==null){

            projection  = (IProjection) (getParameters().getDynValue(WMTSRasterProviderParameters.WMTS_CRS_PARAMETER_NAME));

        }

        return this.projection;

    }

    protected WMTSClient getWMTSClient() throws InitializeException {

        if (wmtsClient == null) {

            WMTSRasterProviderParameters parameters = (WMTSRasterProviderParameters) getParameters();

            URL service = parameters.getService();

            try {

                wmtsClient = WMTSOGCLocator.getManager().createWMTSClient(service.toString());

                Boolean forceChangeAxisOrder = (Boolean) getParameters().getDynValue(WMTSRasterProviderParameters.WMTS_FORCECHANGEAXISORDER_PARAMETER_NAME);

                if(forceChangeAxisOrder!=null){

                    wmtsClient.setForceChangeAxisOrder(forceChangeAxisOrder.booleanValue());

                } else {

                    wmtsClient.setForceChangeAxisOrder(false);

                }

                wmtsClient.connect(true, null);

            } catch (IOException e) {

                throw new InitializeException("Can't create WMTSClient with from service '" + service.toString() + "'",

                    e);

            }

        }

        return wmtsClient;

    }

    protected int getRowsPerTile() {

        return this.rowsPerTile;

    };

    protected int getColumnsPerTile() {

        return this.columnsPerTile;

    };

    @Override

    public Image getImageLegend() {

        File file;

        BufferedImage img = null;

        try {

        WMTSLayer wmtsLayer = getWMTSClient().getLayer(getLayerName());

        WMTSStyle wmtsStyle = null;

        List<WMTSStyle> wmtsStyles = wmtsLayer.getStyle();

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

            wmtsStyle = (WMTSStyle) iterator.next();

            if (wmtsStyle.getIdentifier().equalsIgnoreCase(wmtsStatus.getStyle())) {

                break;

            }

            wmtsStyle = null;

        }

            file = getWMTSClient().getLegendGraphic(wmtsLayer, wmtsStyle, null);

            img = ImageIO.read(file);

        } catch (InitializeException | WMTSException | IOException e) {

            logger.warn("Can't read image legend of WMTS Provider", e);

        }

        return img;

    }

    @Override

    public BufferDimensions getDimensions() throws InitializeException {

        if(this.dimensions==null){;

            Double pixelSize = getTileStruct().getPixelSizePerZoomLevel().get(getMaxZoomLevel());

            Envelope envelope = this.getEnvelope();

            int rows = (int)Math.round(envelope.getLength(DIMENSIONS.Y)/pixelSize);

            int columns = (int)Math.round(envelope.getLength(DIMENSIONS.X)/pixelSize);

            this.dimensions = BufferLocator.getBufferManager().createBufferDimensions(rows, columns, envelope);

        }

        return this.dimensions;

    }

    /**

     * @return the maxZoomLevel

     */

    public int getMaxZoomLevel() {

        return maxZoomLevel;

    }

//    /**

//     * @param maxZoomLevel the maxZoomLevel to set

//     */

//    public void setMaxZoomLevel(int maxZoomLevel) {

//        this.maxZoomLevel = maxZoomLevel;

//    }

}