Application: gvSIG desktop » gvSIG raster

		path = path + File.separator + fileName + getSuffix();

	public static String getSuffix() {

		return ".mrf";

	}

import org.gvsig.raster.impl.provider.MemoryTileMatrixBuffer;

import org.gvsig.raster.impl.provider.tile.FileTileServer;

			if(noData == null && providerList.get(i).getNoDataValue().isDefined()) {

				noData.setFileName(getParameters().getURI());

			}

	public int[] getBandCountByProvider() {

		int[] n = new int[providerList.size()];

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

			n[i] = providerList.get(i).getBandCount();

		}

		return n;

	}

	public BandList getDefaultBandList() {

		BandList bandList = new BandListImpl();

		int[] nBandsByProvider = getBandCountByProvider();

		int nBands = 0;

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

			nBands = Math.max(nBandsByProvider[i], nBands);

		}

		for (int iBand = 0; iBand < nBands; iBand++) {

			try {

				bandList.addBand(new DatasetBandImpl(getURI(), iBand, getDataType()[0], nBands));

			} catch (BandNotFoundInListException e1) {

			}	

		}

		int[] drawableBands = new int[bandList.getBandCount()];

		for (int i = 0; i < bandList.getBandCount(); i++) {

			drawableBands[i] = i;

		}

		bandList.setDrawableBands(drawableBands);

		return bandList;

	}

		MemoryTileMatrixBuffer matrixBuffer = new MemoryTileMatrixBuffer(tileList);

		MemoryTileMatrixBuffer matrixBuffer = new MemoryTileMatrixBuffer(tileList);

		MemoryTileMatrixBuffer matrixBuffer = new MemoryTileMatrixBuffer(tileList);

		if(tileServer == null)

			tileServer = new FileTileServer(this);

		return tileServer;

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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.

 *

 */

package org.gvsig.raster.mosaic.io;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLibrary;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.BandList;

import org.gvsig.fmap.dal.coverage.datastruct.DatasetBand;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.datastruct.NoData;

import org.gvsig.fmap.dal.coverage.exception.BandAccessException;

import org.gvsig.fmap.dal.coverage.exception.BandNotFoundInListException;

import org.gvsig.fmap.dal.coverage.exception.FileNotOpenException;

import org.gvsig.fmap.dal.coverage.exception.FileNotSupportedException;

import org.gvsig.fmap.dal.coverage.exception.HistogramException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSetViewException;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.ParsingException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.exception.RmfSerializerException;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.coverage.store.props.HistogramComputer;

import org.gvsig.fmap.dal.coverage.store.props.Statistics;

import org.gvsig.fmap.dal.coverage.store.props.TimeSeries;

import org.gvsig.fmap.dal.coverage.util.MathUtils;

import org.gvsig.fmap.dal.coverage.util.RasterUtils;

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

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

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

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

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

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

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.TileCache;

import org.gvsig.raster.cache.tile.TileCacheLibrary;

import org.gvsig.raster.cache.tile.TileCacheLocator;

import org.gvsig.raster.cache.tile.TileCacheManager;

import org.gvsig.raster.cache.tile.exception.TileBuildException;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.cache.tile.layer.TiledLayer;

import org.gvsig.raster.cache.tile.provider.CacheStruct;

import org.gvsig.raster.cache.tile.provider.TileListener;

import org.gvsig.raster.cache.tile.provider.TileServer;

import org.gvsig.raster.impl.datastruct.BandListImpl;

import org.gvsig.raster.impl.datastruct.DatasetBandImpl;

import org.gvsig.raster.impl.datastruct.ExtentImpl;

import org.gvsig.raster.impl.provider.DefaultRasterProvider;

import org.gvsig.raster.impl.provider.MemoryTileMatrixBuffer;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.tile.FileTileServer;

import org.gvsig.raster.impl.store.AbstractRasterDataParameters;

import org.gvsig.raster.impl.store.DefaultStoreFactory;

import org.gvsig.raster.impl.store.properties.DataStoreTransparency;

import org.gvsig.raster.impl.store.properties.SimpleProviderHistogramComputer;

import org.gvsig.raster.impl.store.properties.SimpleProviderStatistics;

import org.gvsig.raster.mosaic.io.downloader.MosaicTileServer;

import org.gvsig.timesupport.RelativeInstant;

import org.gvsig.timesupport.Time;

import org.gvsig.timesupport.TimeSupportLocator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.TaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Data provider for raster mosaics

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class MosaicProvider2 extends DefaultRasterProvider {

	public static String                     NAME                     = "Mosaic Raster";

	public static String                     DESCRIPTION              = "Mosaic Raster Support";

	public final String                      METADATA_DEFINITION_NAME = NAME;

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

	private boolean                          open                     = false;

	private RasterUtils                      util                     = RasterLocator.getManager().getRasterUtils();

	private MathUtils                        math                     = RasterLocator.getManager().getMathUtils();

    protected static String[]                formatList               = null;

    //private MosaicRasterFormat               mosaicRasterFormat       = null;

    private List<RasterProvider>             providerList             = null;

    private double                           pixelSize                = 0D;

    private Extent                           extent                   = null;

	private double                           width                    = 0;

	private double                           height                   = 0;

	private Extent                           viewRequest              = null;

	private TiledLayer                       tiledLayer               = null;

	//This provider needs a MosaicTileServer by set of layers

	private HashMap<String, MosaicTileServer>

	                                         tileServerMap            = new HashMap<String, MosaicTileServer>();

	private ArrayList<RasterProvider>        selectedProviders        = new ArrayList<RasterProvider>();

	public static void register() {

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

		registerFormats();

		if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

			dataman.registerStoreProvider(NAME,

					MosaicProvider2.class, MosaicDataParametersImpl.class);

		}

		if(DALFileLocator.getFilesystemServerExplorerManager() != null)

			DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

					NAME, DESCRIPTION,

					MosaicServerExplorer.class);

		if (!dataman.getExplorerProviders().contains(NAME)) {

			dataman.registerExplorerProvider(NAME, MosaicServerExplorer.class, MosaicServerExplorerParameters.class);

		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	@SuppressWarnings("deprecation")

	private static void registerFormats() {

		formatList      = new String[] {"mrf"};

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

			RasterLocator.getManager().addFormat(formatList[i], MosaicProvider2.class);

	}

	public String[] getFormatList() {

		return formatList;

	}

	/**

	 * Returns true if the extension is supported and false if doesn't

	 * @param ext

	 * @return

	 */

	public boolean isExtensionSupported(String ext) {

		if(ext.indexOf(".") != -1)

			ext = ext.substring(ext.lastIndexOf(".") + 1, ext.length());

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

			if(formatList[i].compareTo(ext) == 0)

				return true;

		}

		return false;

	}

	public MosaicProvider2() {

	}

	/**

	 * Opens the dataset.

	 * @param proj Projection

	 * @param fName File name

	 * @throws NotSupportedExtensionException

	 */

	public MosaicProvider2(String params) throws NotSupportedExtensionException, OpenException {

		super(params);

		if(params instanceof String) {

			MosaicDataParametersImpl p = new MosaicDataParametersImpl();

			p.setURI((String)params);

			super.init(p, null, ToolsLocator.getDynObjectManager()

					.createDynObject(

							MetadataLocator.getMetadataManager().getDefinition(

									DataStore.METADATA_DEFINITION_NAME)));

			init(p, null);

		}

	}

	public MosaicProvider2 (MosaicDataParametersImpl params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		init(params, storeServices);

	}

	/**

	 * Build file references

	 * @param proj Projection

	 * @param param Load parameters

	 * @throws NotSupportedExtensionException

	 */

	public void init (AbstractRasterDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		setParam(storeServices, params);

		openFromMrf();

		calcMetadataFromParams();

		super.init();

		try {

			loadFromRmf(getRmfBlocksManager());

		} catch (ParsingException e) {

			//No lee desde rmf

		}

		open = true;

	}

	/**

	 * Calculates metadata using the parameters

	 */

	private void calcMetadataFromParams() {

		uri = getParameters().getURI();

		providerList = getParameters().getProviders();

		pixelSize = getParameters().getPixelSize();

		setColorInterpretation(providerList.get(0).getColorInterpretation().cloneColorInterpretation());

		//Se le pone banda de transparencia siempre

		if(providerList.get(0).getDataType()[0] == Buffer.TYPE_BYTE) {

			transparency = new DataStoreTransparency();

			transparency.setTransparencyBand(getBandCount() - 1);

		} else 

			transparency = providerList.get(0).getTransparency();

		extent = null;

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

			if(extent == null)

				extent = providerList.get(i).getExtent();

			else

				extent = extent.encloseBoundinBoxes(providerList.get(i).getExtent());

			//Usa el primer NoData de la primera imagen que tenga un valor asignado

			if(noData == null && providerList.get(i).getNoDataValue().isDefined()) {

				noData = providerList.get(i).getNoDataValue();

				noData.setFileName(getParameters().getURI());

			}

		}

		width = extent.width() / pixelSize;

		height = extent.height() / pixelSize;

		ownTransformation = new AffineTransform(pixelSize, 0, 

							0, -pixelSize, 

							extent.getULX(), extent.getULY());

		externalTransformation = (AffineTransform) ownTransformation.clone();

		((MosaicDataParametersImpl)getParameters()).resetParamsChanged();

	}

	/**

	 * Loads the specific provider

	 * @param file

	 * @return

	 * @throws NotSupportedExtensionException

	 * @throws FileNotSupportedException 

	 */

	@SuppressWarnings("unchecked")

	private RasterProvider loadProvider(String file, DataStoreProviderServices storeServices) throws ProviderNotRegisteredException, InitializeException {

		DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

		DataStoreProvider prov = null;

		if(file != null) {

			//We have to locate a provider's name which manages the selected file

			//A FilesystemServerExplorer will give a getProviderNames service

			FilesystemServerExplorerParameters paramsExplorer = (FilesystemServerExplorerParameters)dataManager.createServerExplorerParameters(FilesystemServerExplorer.NAME);

			FilesystemServerExplorer serverExplorer = null;

			try {

				paramsExplorer.setRoot(File.separator);

				serverExplorer = (FilesystemServerExplorer)dataManager.openServerExplorer(FilesystemServerExplorer.NAME, paramsExplorer);

			} catch (ValidateDataParametersException e) {

				throw new InitializeException(e);

			}

			File f = new File(file);

			//Gets the list of provider's name to manage the file

			List<String> provName = serverExplorer.getProviderNameList(f);

			if(provName.size() > 0) {

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

					//Gets the first provider what is not a TileProvider

					if(provName.get(i).compareTo("Tile Store") != 0) {

						DataStoreParameters newparams = dataManager.createStoreParameters(provName.get(i));

						((FilesystemStoreParameters)newparams).setFile(f); 

						prov = dataManager.createProvider(storeServices, newparams);

					}

				}

			}

		}

		if(prov != null && prov instanceof RasterProvider) {

			if(((RasterProvider)prov).isRotated())

				throw new InitializeException("Rotation not supported tiling files", new Throwable());

			return (RasterProvider)prov;

		}

		return null;

	}

	/**

	 * Open from a .mrf file. 

	 * This method loads all providers and adds these to the parameters

	 * @throws OpenException

	 */

	private void openFromMrf() throws OpenException {

		if(getParameters().getURI() != null && new File(getParameters().getURI()).exists()) {

			try {

				if(getParameters().getProviders() != null)

					getParameters().getProviders().clear();

				MosaicRasterFormat multiFileFormat = new MosaicRasterFormat();

				multiFileFormat = MosaicRasterFormatSerializer.read(multiFileFormat, getParameters().getURI());

				for (int i = 0; i < multiFileFormat.getNumberOfFiles(); i++) {

					try {

						File file = new File(multiFileFormat.getPathToFile(i));

						if(file.exists()) {

							RasterProvider prov = loadProvider(multiFileFormat.getPathToFile(i), storeServices);

							if(i == 0)

								getParameters().setPixelSize(prov.getCellSize());

							getParameters().addProvider(prov);

						}

					} catch (ProviderNotRegisteredException e) {

						throw new OpenException("A provider can't be loaded", e);

					} catch (InitializeException e) {

						throw new OpenException("A provider can't be initialized", e);

					}

				}

			} catch (IOException e1) {

				throw new OpenException("File .mrf can't be read", e1);

			} catch (ParsingException e1) {

				throw new OpenException("File .mrf can't be parsed", e1);

			}

		} 

	}

	public RasterProvider load() {

		return this;

	}

	/**

	 * Gets the MosaicDataParameters

	 * @return

	 */

	public MosaicDataParameters getParameters() {

		try {

			return (MosaicDataParameters)parameters;

		} catch (ClassCastException e) {

			return null;

		}

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

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

			providerList.get(i).close();

		}

	}

	/**

	 * @return Returns the dataType.

	 */

	public int[] getDataType() {

		if(providerList.get(0).getDataType()[0] == Buffer.TYPE_BYTE) {

			int[] dt = new int[getBandCount()];

			for (int i = 0; i < providerList.get(0).getDataType().length; i++) {

				dt[i] = providerList.get(0).getDataType()[i];

			}

			dt[getBandCount() - 1] = Buffer.TYPE_BYTE;

			return dt;

		}

		return providerList.get(0).getDataType();

	}

	/**

	 * Gets the number of bands

	 * @return 

	 */

	public int getBandCount() {

		if(providerList.get(0).getDataType()[0] == Buffer.TYPE_BYTE)

			return providerList.get(0).getBandCount() + 1;

		return providerList.get(0).getBandCount();

	}

	public String[] getURIByProvider() {

		providerList = getParameters().getProviders();

		String[] uris = new String[providerList.size()];

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

			uris[i] = providerList.get(i).getURI();

		}

		return uris;

	}

	public int[] getBandCountByProvider() {

		int[] n = new int[providerList.size()];

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

			n[i] = providerList.get(i).getBandCount();

		}

		return n;

	}

	public BandList getDefaultBandList() {

		BandList bandList = new BandListImpl();

		int[] nBandsByProvider = getBandCountByProvider();

		int nBands = 0;

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

			nBands = Math.max(nBandsByProvider[i], nBands);

		}

		for (int iBand = 0; iBand < nBands; iBand++) {

			try {

				bandList.addBand(new DatasetBandImpl(getURI(), iBand, getDataType()[0], nBands));

			} catch (BandNotFoundInListException e1) {

			}	

		}

		int[] drawableBands = new int[bandList.getBandCount()];

		for (int i = 0; i < bandList.getBandCount(); i++) {

			drawableBands[i] = i;

		}

		bandList.setDrawableBands(drawableBands);

		return bandList;

	}

	public String getURIByBand(int band) {

		return getURI();

	}

	public double getPixelSizeX() {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		return pixelSize;

	}

	public double getPixelSizeY() {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		return pixelSize;

	}

	public NoData getNoDataValue() {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		return noData;

	}

	public Extent getExtent() {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		return extent;

	}

	public double getCellSize() {

		return pixelSize;

	}

	public Statistics getStatistics() {

		if(stats == null || getParameters().hasParamsChanged()) {

			//First of all read the statistics in the rmf. If these have not been calculated then

			//we'll read the statistics from simple files

			stats = super.getStatistics();

			try {

				loadObjectFromRmf(SimpleProviderStatistics.class, stats);

			} catch (RmfSerializerException e) {

				// Si no se puede cargar del RMF, recalcularemos las estadisticas.

			}

			if(!stats.isCalculated()) {

				calcMetadataFromParams();

				providerList = getParameters().getProviders();

				stats = SimpleProviderStatistics.union(this, providerList);

			}

		}

		return stats;

	}

	public HistogramComputer getHistogramComputer() {

		if(histogram == null || getParameters().hasParamsChanged()) {

			calcMetadataFromParams();

			providerList = getParameters().getProviders();

			try {

				histogram = SimpleProviderHistogramComputer.union(this, providerList);

			} catch (HistogramException e) {

				return null;

			} catch (InterruptedException e) {

				return null;

			}

		}

		return histogram;

	}

	public String getURIOfFirstProvider() {

		return providerList.get(0).getURIOfFirstProvider();

	}

	public long getFileSize() {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		long sizeMosaic = 0;

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

			long[] fs = providerList.get(i).getFileSizeByProvider();

			for (int j = 0; j < fs.length; j++) {

				sizeMosaic += fs[j];

			}

		}

		return sizeMosaic;

	}

	public IProjection getProjection() {

		return proj;

	}

	public void setProjection(IProjection p) {

	}

	public String getInfoByPoint(double x, double y, ICancellable cancellable) {

		return null;

	}

	public int[] getTileSize(int level) {

		return null;

	}

	public int getSourceType() {

		return RasterDataStore.MOSAIC;

	}

	public String translateFileName(String fileName) {

		return fileName;

	}

	public void setView(Extent e) {

		viewRequest = new ExtentImpl(e);

	}

	public Extent getView() {

		return viewRequest;

	}

	public double getWidth() {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		return width;

	}

	public double getHeight() {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		return height;

	}

	@SuppressWarnings("deprecation")

	public Object readBlock(int pos, int blockHeight, double scale)

		throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		blockHeight = pos + blockHeight > getHeight() ? (int)(getHeight() - pos) : blockHeight;

		Buffer buf = RasterLocator.getManager().createBuffer(getDataType()[0], (int)getWidth(), blockHeight, getBandCount(), true);

		BandList bandList = new BandListImpl();

		bandList.clear();

		int[] drawableBands = new int[getBandCount()];

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

			try {

				int dataType = getDataType()[i];

				DatasetBand band = new DatasetBandImpl(getURIByBand(i), 

													getBandPositionByProvider(i), 

													dataType, 

													getBandCount());

				bandList.addBand(band, i);

				drawableBands[i] = i;

			} catch(BandNotFoundInListException ex) {

				//No a�adimos la banda

			}

		}

		bandList.setDrawableBands(drawableBands);

		return getWindow(0, pos, bandList, buf);

	}

	public Object getData(int x, int y, int band) throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		return null;

	}

	public void getWindow(Extent ex, int bufWidth, int bufHeight, 

			BandList bandList, TileListener listener, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

	}

	public Buffer getWindow(Extent extent, BandList bandList, Buffer rasterBuf, TaskStatus status) 

		throws ProcessInterruptedException, RasterDriverException {

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		setView(extent);

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

			RasterProvider provider = providerList.get(i);

			Buffer buf = ((DefaultRasterProvider)provider).getWindow(extent, bandList, rasterBuf, status);

		}

	}

	public Buffer getWindow(double ulx, double uly, double w, double h, 

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

		//cut image

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		Extent ext = getExtent();

		Point2D pInit = rasterToWorld(new Point2D.Double(0, 0));

		Point2D pEnd = rasterToWorld(new Point2D.Double(getWidth(), getHeight()));

		double wRaster = Math.abs(pEnd.getX() - pInit.getX());

		double hRaster = Math.abs(pEnd.getY() - pInit.getY());

		double lrx = (((ext.getULX() - wRaster) > ext.maxX()) || ((ext.getULX() - wRaster) < ext.minX())) ? (ulx + w) : (ulx - w);

		double lry = (((ext.getULY() - hRaster) > ext.maxY()) || ((ext.getULY() - hRaster) < ext.minY())) ? (uly + h) : (uly - h);

		Extent selectedExtent = new ExtentImpl(ulx, uly, lrx, lry);

		setView(selectedExtent);

		return getWindow(selectedExtent, 

				rasterBuf.getWidth(), rasterBuf.getHeight(), bandList, rasterBuf, false, status);

	}

	public Buffer getWindow(Extent extent, int bufWidth, int bufHeight, 

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

		//draw method

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		setView(extent);

		String layerName = getLayerNameFromSelection(getParameters().getTimeSelection());

		List<Tile> tileList = null;

		try {

			tileList = getTileList(extent, bandList, bufWidth, bufHeight, layerName);

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

				tiledLayer.getTile(tileList.get(i));

			}

		} catch (TileGettingException e) {

			throw new RasterDriverException("Error getting the tile list", e);

		} catch (TileBuildException e) {

			throw new RasterDriverException("Error building the tile list", e);

		}

		MemoryTileMatrixBuffer matrixBuffer = new MemoryTileMatrixBuffer(tileList);

		if(	tileList.get(0).getData().length > 1 && 

			getDataType()[0] == Buffer.TYPE_BYTE &&

			rasterBuf.getBandCount() == 1 &&

			bandList.getDrawableBands()[0] == getBandCount())

			return matrixBuffer.getWindow(extent, rasterBuf, true);

		else

			return matrixBuffer.getWindow(extent, rasterBuf, false);

	}

	public Buffer getWindow(int x, int y, 

			BandList bandList, Buffer rasterBuf) throws ProcessInterruptedException, RasterDriverException {

		//Layer with real resolution

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		int w = rasterBuf.getWidth();

		int h = rasterBuf.getHeight();

		Rectangle2D r = new Rectangle2D.Double(x, y, w, h);

		setView(

		new ExtentImpl( rasterUtil.getMapRectFromPxRect(getExtent().toRectangle2D(),

					getWidth(),

					getHeight(),

					r))

		);

		String layerName = getLayerNameFromSelection(getParameters().getTimeSelection());

		CacheStruct struct = getTileServer(layerName).getStruct();

		createTiledLayer(layerName); //Creates a new layer when the file type changes

		List<Tile> tileList = struct.getTileList(r);

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

			tileList.get(i).setDownloaderParams("BandList", bandList.clone());

		}

		try {

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

				tiledLayer.getTile(tileList.get(i));

			}

		} catch (TileGettingException e) {

			throw new RasterDriverException("Error getting the tile list", e);

		}

		MemoryTileMatrixBuffer matrixBuffer = new MemoryTileMatrixBuffer(tileList);

		return matrixBuffer.getWindow(r, rasterBuf);

	}

	public Buffer getWindow(int x, int y, int w, int h, 

			BandList bandList, Buffer rasterBuf, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

		if(rasterBuf.getWidth() == w && rasterBuf.getHeight() == h)

			return getWindow(x, y, bandList, rasterBuf);

		if(getParameters().hasParamsChanged())

			calcMetadataFromParams();

		setView(

				new ExtentImpl( rasterUtil.getMapRectFromPxRect(getExtent().toRectangle2D(),

						getWidth(),

						getHeight(),

						new Rectangle2D.Double(x, y, w, h)))

		);

		return null;

	}

	public int getBlockSize() {

		return 0;

	}

	public boolean isTiled() {

		return false;

	}

	public int getOverviewCount(int band) throws BandAccessException, RasterDriverException {

		return 0;

	}

	public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException {

		return 0;

	}

	public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException {

		return 0;

	}

	public boolean isOverviewsSupported() {

		return false;

	}

	public boolean isReproyectable() {

		return false;

	}

	public String getName() {

		return NAME;

	}

	public void setStatus(RasterProvider provider) {

		if(provider instanceof MosaicProvider2) {

		}

	}

	public boolean isTimeSupported() {

		return true;

	}

	public boolean isMosaic() {

		return true;

	}

	public void deleteLayerFromCache() {

		String layerName = getLayerNameFromSelection(null);

		TileCacheManager  manager = TileCacheLocator.getManager();

		TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

		TiledLayer newLayer = tileCache.createLayer(getTileServer(layerName), TileCacheLibrary.DEFAULT_STRUCTURE);

		tileCache.removeLayer(newLayer);

	}

	/**

	 * Gets the layer name using the time selection and visibility

	 * @param t

	 * @return

	 */

	private String getLayerNameFromSelection(Time t) {

		String name = "";

		MessageDigest md = null;

		try {

			md = java.security.MessageDigest.getInstance("MD5");

		} catch (NoSuchAlgorithmException e) {

		}

		//Without time selected

		if(t == null || selectedProviders.size() != providerList.size()) {

			selectedProviders.clear();

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

				RasterProvider prov = providerList.get(i);

				selectedProviders.add(prov);

				if(!((RasterDataParameters)prov.getDataParameters()).isVisible())

					name += prov.getURI().substring(prov.getURI().lastIndexOf(File.separator) + 1, prov.getURI().length());

			}

		} else {

			selectedProviders.clear();

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

				try {

					TimeSeries tSeries = providerList.get(i).getTimeSerials();

					ArrayList<?> tList = tSeries.getTimeList();

					for (int j = 0; j < tList.size(); j++) {

						Object obj = tList.get(i);

						RelativeInstant instant = null;

						if(obj instanceof Date) {

							Date s = (Date)obj;

							instant = TimeSupportLocator.getManager().createRelativeInstant(s);

						}

						if(obj instanceof Double) {

							long s = ((Double)obj).longValue();

							instant = TimeSupportLocator.getManager().createRelativeInstant(s);

						}

						if( instant != null && 

							t.intersects(instant) &&

							!selectedProviders.contains(providerList.get(i))) {

							RasterProvider prov = providerList.get(i);

							selectedProviders.add(prov);

							if(!((RasterDataParameters)prov.getDataParameters()).isVisible())

								name += prov.getURI().substring(prov.getURI().lastIndexOf(File.separator) + 1, prov.getURI().length());

						}

					}

				} catch (RmfSerializerException e) {

					logger.debug("Error reading rmf time serials", e);

				}

			}

		}

		if(md != null) {

			md.update(name.getBytes());

			return math.convertToHex(md.digest());

		} else {

			return name;

		}

	}

	/**

	 * Creates a new tiled layer if this hasn't been created yet or the ID has changed. 

	 * An ID could changed because the file type has changed when the user uses WMTS properties.

	 */

	private TileCache createTiledLayer(String layerName) {

		TileCacheManager  manager = TileCacheLocator.getManager();

		TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

		TiledLayer newLayer = tileCache.createLayer(getTileServer(layerName), TileCacheLibrary.DEFAULT_STRUCTURE);

		if(tiledLayer == null || newLayer.getID().compareTo(tiledLayer.getID()) != 0)

			tiledLayer = newLayer;

		return tileCache;

	}

	/**

	 * Gets the tile list in a selected extent

	 * @param ex

	 * @param bandList

	 * @param bufWidth

	 * @param bufHeight

	 * @return

	 * @throws TileBuildException 

	 */

	/*private List<Tile> getTileList(Extent ex, BandList bandList, int bufWidth, int bufHeight, String layerName) throws TileBuildException {

		CacheStruct struct = getTileServer(layerName).getStruct();

		createTiledLayer(layerName); //Creates a new layer when the file type changes

		Extent adjustedExtent = util.intersection(getExtent(), ex);

		double newBufWidth = (adjustedExtent.width() * bufWidth) / ex.width();

		double pixelSizeRequest = adjustedExtent.width() / newBufWidth; 

		List<Tile> tileList = struct.getTileList(new Point2D.Double(adjustedExtent.getULX(), adjustedExtent.getULY()), 

				new Point2D.Double(adjustedExtent.getLRX(), adjustedExtent.getLRY()), 

				pixelSizeRequest);

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

			tileList.get(i).setDownloaderParams("BandList", bandList.clone());

		}

		return tileList;

	}*/

	public TileServer getTileServer() {

		if(tileServer == null)

			tileServer = new FileTileServer(this);

		return tileServer;

	}

	/**

	 * Gets the tile server from the Hashmap

	 * @param layerName

	 * @return

	 */

	public TileServer getTileServer(String layerName) {

		MosaicTileServer tileServer = tileServerMap.get(layerName);

		if(tileServer == null) {

			tileServer = new MosaicTileServer(this, 

					providerList,

					layerName,

					getParameters().getOverlapMethod(),

					getParameters().getColorCorrectionMethod(),

					getNoDataValue());

			tileServerMap.put(layerName, tileServer);

		}

		return tileServer;

	}

}

	public void addSrcFile(Object data, String text, int nBands, int datatype, double cellsize, double nodata);

	public void addDstFile(Object data, String text, int nBands, int datatype, double cellsize, double nodata);

package org.gvsig.raster.mosaic.swing.impl.options;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import javax.swing.BorderFactory;

import javax.swing.JPanel;

import org.gvsig.i18n.Messages;

public class CellSizePanel extends JPanel {

	private static final long serialVersionUID = 1L;

	public CellSizePanel() {

		init();

	}

	private void init() {

		setLayout(new GridBagLayout());

		setBorder(BorderFactory.createTitledBorder(Messages.getText("cellsize")));

		GridBagConstraints gbc = new GridBagConstraints();

		gbc.insets = new Insets(2, 2, 2, 2);

		gbc.fill = GridBagConstraints.HORIZONTAL;

		gbc.weightx = 1.0;

		gbc.weighty = 0;

		//add(getScrollTableSrc(), gbc);

	}

}

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreProvider;

import org.gvsig.fmap.dal.coverage.store.parameter.TileDataParameters;

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

import org.gvsig.raster.mosaic.io.MosaicRasterFormat;

		double nodata = 0;

		public TableEntry(String text, Object obj, int bandCount, int dataType, double cellsize, double nodata) {

			this.nodata = nodata;

	public void addSrcFile(Object data, String text, int nBands, int datatype, double cellsize, double nodata) {

		TableEntry entry = new TableEntry(text, data, nBands, datatype, cellsize, nodata);

	public void addDstFile(Object data, String text, int nBands, int datatype, double cellsize, double nodata) {

		TableEntry entry = new TableEntry(text, data, nBands, datatype, cellsize, nodata);

	private boolean cache = true;

			newParamsMosaic.setURI(folder + File.separator + file + MosaicRasterFormat.getSuffix());

			if(cache) {

				DataManager manager = DALLocator.getDataManager();

				TileDataParameters tileParams = null;

				try {

					tileParams = (TileDataParameters) manager.createStoreParameters("Tile Store");

				} catch (ProviderNotRegisteredException e) {

					throw new InitializeException(e.getMessage(), e);

				}

				tileParams.setDataParameters(newParamsMosaic);

				CoverageStoreProvider provider = (CoverageStoreProvider)dataManager.createProvider(null, tileParams);

				RasterDataStore store = RasterLocator.getManager().getProviderServices().open(provider, tileParams);

				return store;

			} else {

				MosaicProvider provider = (MosaicProvider)dataManager.createProvider(null, newParamsMosaic);

				RasterDataStore store = RasterLocator.getManager().getProviderServices().open(provider, newParamsMosaic);

				return store;

			}

		double nodata = -99999.0;

		desc.addSrcFile(null, "capa 1", 3, Buffer.TYPE_BYTE, 0.5, nodata);

		desc.addSrcFile(null, "capa 2", 4, Buffer.TYPE_BYTE, 0.5, nodata);

		desc.addSrcFile(null, "capa 3", 5, Buffer.TYPE_BYTE, 0.5, nodata);

		desc.addSrcFile(null, "capa 4", 6, Buffer.TYPE_BYTE, 30, nodata);

		desc.addSrcFile(null, "capa 5", 3, Buffer.TYPE_BYTE, 15, nodata);

		desc.addSrcFile(null, "capa 6", 6, Buffer.TYPE_BYTE, 15, nodata);

		desc.addSrcFile(null, "capa 7", 12, Buffer.TYPE_SHORT, 0.5, nodata);

		desc.addSrcFile(null, "capa 8", 4, Buffer.TYPE_INT, 0.5, nodata);

		desc.addSrcFile(null, "capa 9", 6, Buffer.TYPE_SHORT, 0.5, nodata);

		desc.addSrcFile(null, "capa 10", 0, Buffer.TYPE_FLOAT, 0.5, nodata);

		double nodata = -99999.0;

			desc.addDstFile(null, fList[i].toString(), 3, Buffer.TYPE_BYTE, 0.5, nodata);

		double nodata = -99999.0;

			desc.addDstFile(null, folderList[i].toString(), 3, Buffer.TYPE_BYTE, 0.5, nodata);

Open_timeserie=Abrir serie temporal raster (.tsf)

error_creating_provider=Error creando el proveedor de datos

add_directory=A?adir directorio

add_files=A?adir ficheros

see_path=Ver rutas

modify_options=Opciones

modify_options_tip=Modificar opciones para la generaci?n del mosaico

create=Crear

add=A?adir

create_mosaic=Crear mosaico

options=Opciones

select_directory=Seleccionar directorio

select_file=Seleccionar fichero

select_output_file=Fichero de salida para el Mosaico

mosaic_panel=Mosaico

delete_cache=?Atenci?n! A?adir o borrar ficheros a la capa borrar? la cach? de esta. \n ?Desea continuar?

delete_cache_button=Borrar cach?

delete_cache_button_tip=Borrar cach? de las capas visibles

table_cant_be_empty=La lista de ficheros no puede estar vacia

removefile_mosaic_error=Se ha producido un error eliminando la ficheros del mosaico

addfile_mosaic_error=Se ha producido un error a?adiendo la ficheros del mosaico

deleting_cache=Se va a borrar la cach? de teselas de la capa y los ficheros visibles. \n ?Desea continuar?

import org.gvsig.fmap.dal.coverage.store.parameter.TileDataParameters;

		MosaicDataParameters params = null; 

		if(mainRasterStore.getParameters() instanceof MosaicDataParameters)	{	

				params = (MosaicDataParameters)mainRasterStore.getParameters();

		}

		if(mainRasterStore.getParameters() instanceof TileDataParameters) {

			TileDataParameters tileparams = (TileDataParameters)mainRasterStore.getParameters();

			params = (MosaicDataParameters)tileparams.getDataParameters();

		}

							store.getCellSize(),

							store.getNoDataValue().getValue().doubleValue());

							store.getCellSize(),

							store.getNoDataValue().getValue().doubleValue());

		Messages.addResourceFamily("org.gvsig.raster.mosaic.app.i18n.text",

						lyrRaster.getDataStore().getCellSize(),

						lyrRaster.getNoDataValue().getValue().doubleValue());