Application: gvSIG desktop » gvSIG raster

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.raster.multifile</artifactId>

	<packaging>pom</packaging>

	<version>2.2.241</version>

	<name>${project.artifactId}</name>

	<description>Raster multifile support for gvSIG</description>

	<inceptionYear>2013</inceptionYear>

	<parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.desktop</artifactId>

      <version>2.0.445</version>

  </parent>

        <properties>

            <!-- El plugin versions:use-latest-versions falla con scope import -->

            <!-- asi que toca usar el versions:update-properties que si que funciona -->

            <org.gvsig.raster.version>2.2.265</org.gvsig.raster.version>

        </properties>

    <repositories>

      <repository>

        <id>gvsig-public-http-repository</id>

        <name>gvSIG maven public HTTP repository</name>

        <url>http://devel.gvsig.org/m2repo/j2se</url>

        <releases>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </releases>

        <snapshots>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </snapshots>

      </repository>

    </repositories>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.multifile/tags/org.gvsig.raster.multifile-2.2.241</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.multifile/tags/org.gvsig.raster.multifile-2.2.241</developerConnection>

        <url>https://devel.gvsig.org/redmine/projects/gvsig-raster/repository/show/org.gvsig.raster.multifile/tags/org.gvsig.raster.multifile-2.2.241</url>

    </scm>

	<developers>

		<developer>

			<id>nbrodin</id>

			<name>Nacho Brodin</name>

			<email>nachobrodin@gmail.com</email>

			<roles>

				<role>Architect</role>

				<role>Developer</role>

			</roles>

		</developer>

	</developers>

	<dependencyManagement>

    	<dependencies>

                        <dependency>

                                <groupId>org.gvsig</groupId>

                                <artifactId>org.gvsig.raster</artifactId>

                                <version>${org.gvsig.raster.version}</version>

                                <type>pom</type>

                                <scope>import</scope>

                        </dependency>

        <dependency>

          <groupId>org.gvsig</groupId>

          <artifactId>org.gvsig.raster.multifile.io</artifactId>

          <version>2.2.241</version>

        </dependency>

    	</dependencies>

    </dependencyManagement>

	<build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-release-plugin</artifactId>

                <configuration>

                    <tagBase>https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.multifile/tags/</tagBase>

                    <goals>deploy</goals>

                </configuration>

            </plugin>

        </plugins>

    </build>

	<modules>

		<module>org.gvsig.raster.multifile.io</module>

		<module>org.gvsig.raster.multifile.app.multifileclient</module>

	</modules>

</project>

/* 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.multifile.io;

import java.util.List;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

/**

 * Explorer for a Multifile

 */

public class MultiFileServerExplorer extends AbstractDataServerExplorer implements DataServerExplorerProvider  {

	/**

	 * 

	 */

	public MultiFileServerExplorer() {

            super(null, null);

	}

	/**

	 * @param parameters

	 * @param services

	 * @throws InitializeException

	 */

	public MultiFileServerExplorer(

			MultiFileServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

            super(parameters, services);

	}

        @Override

        public DataStoreParameters get(String string) throws DataException {

            return null;

        }

	public String getDataStoreProviderName() {

		return MultiFileProvider.NAME;

	}

	public String getDescription() {

		return MultiFileProvider.DESCRIPTION;

	}

	public List<String> getDataStoreProviderNames() {

		return null;

	}

	public String getProviderName() {

		return MultiFileProvider.NAME;

	}

	public void remove(DataStoreParameters parameters) throws RemoveException {

		throw new UnsupportedOperationException();

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public boolean canAdd() {

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	public List<DataStoreParameters> list() throws DataException {

		return null;

	}

	public List<DataStoreParameters> list(int mode) throws DataException {

		return null;

	}

	public int getMode() {

		return DataServerExplorer.MODE_RASTER;

	}

}

/* 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.multifile.io;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

/**

 * MultiFileFormat information

 *

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

 */

public class MultiFileFormat {

	public ArrayList<File>   fileList                       = new ArrayList<File>();

	private String           name                           = null;

	/**

	 * Gets the name of this serial

	 * @return String

	 */

	public String getName() {

		return name;

	}

	/**

	 * Sets the name of this serie

	 * @param name

	 */

	public void setName(String name) {

		this.name = name;

	}

	/**

	 * Gets the number of files of this serial

	 * @return int

	 */

	public int getNumberOfFiles() {

		return fileList.size();

	}

	/**

	 * Gets the path of the file in the selected position

	 * @param file

	 * @return String

	 */

	public String getPathToFile(int file) {

		return fileList.get(file).getAbsolutePath();

	}

	/**

	 * Adds a file to the list

	 * @param file

	 */

	public void addFile(File file) {

		fileList.add(file);

	}

	/**

	 * Cleans the list of files

	 */

	public void clean() {

		fileList.clear();

		name = null;

	}

	/**

	 * @param fileName

	 * @param path

	 * @param uriList

	 * @return String

	 * @throws IOException

	 */

	public static String saveMultiFileFormat(String fileName, String path, ArrayList<File> uriList) throws IOException {

		path = path + File.separator + fileName + ".mff";

		MultiFileFormat format = new MultiFileFormat();

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

			format.addFile(uriList.get(i));

		}

		format.setName(fileName);

		format.write(path);

		return path;

	}

	/**

	 * Writes a MultiFileFormat to disk

	 * @param fileName

	 * @param file

	 * @throws IOException

	 */

	public void write(String fileName) throws IOException {

		MultiFileFormatSerializer.write(this, fileName);

	}

}

/* 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.multifile.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.net.URI;

import java.net.URISyntaxException;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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.store.parameter.RasterDataParameters;

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

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

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

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

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

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

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.provider.TileServer;

import org.gvsig.raster.impl.buffer.SpiRasterQuery;

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.locator.LocatorException;

/**

 * A data provider for a multiband image readed from different files

 *

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

 */

public class MultiFileProvider extends AbstractRasterProvider {

	public static String                     NAME                     = "Multifile Raster";

	public static String                     DESCRIPTION              = "Multifile Raster Support";

	public final String                      METADATA_DEFINITION_NAME = NAME;

	private Extent                           viewRequest              = null;

	private TileServer                       tileServer               = null;

	private boolean                          open                     = false;

    private DataStoreTransparency            fileTransparency         = null;

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

    protected static String[]                formatList               = null;

	/**

	 *

	 */

	public static void register() {

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

		registerFormats();

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

			dataman.registerStoreProvider(NAME,

					MultiFileProvider.class, MultiFileDataParametersImpl.class);

		}

//		if(DALFileLocator.getFilesystemServerExplorerManager() != null)

//			DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

//					NAME, DESCRIPTION,

//					MultiFileServerExplorer.class);

//

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

//			dataman.registerExplorerProvider(NAME, MultiFileServerExplorer.class, MultiFileServerExplorerParameters.class);

//		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	private static void registerFormats() {

		formatList      = new String[] {

				"mff"};

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

			RasterLocator.getManager().getProviderServices().addFormat(

					formatList[i],

					MultiFileProvider.class);

	}

	/**

	 *

	 */

	public MultiFileProvider() {

	}

	/**

	 * Opens the dataset.

	 * @param params

	 * @param proj Projection

	 * @param fName File name

	 * @throws NotSupportedExtensionException

	 * @throws OpenException

     * @deprecated use {@link #MultiFileProvider(URI)}, this constructor will be removed in gvSIG 2.5

	 */

	public MultiFileProvider(String params) throws NotSupportedExtensionException, OpenException {

		super(params);

        logger.info("Deprecated use of MultiFileProvider constructor");

		if(params instanceof String) {

			MultiFileDataParameters p = new MultiFileDataParametersImpl();

			URI uriObj;

            try {

                uriObj = new URI((String)params);

            } catch (URISyntaxException e) {

                throw new OpenException("Can't create uri from "+(String)params, e);

            }

			p.setURI(uriObj);

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

					.createDynObject(

							MetadataLocator.getMetadataManager().getDefinition(

									DataStore.METADATA_DEFINITION_NAME)));

			init(p, null);

		}

	}

	 /**

     * Opens the dataset.

	 * @param uri

     * @param proj Projection

     * @param fName File name

     * @throws NotSupportedExtensionException

	 * @throws OpenException

     */

    public MultiFileProvider(URI uri) throws NotSupportedExtensionException, OpenException {

        super(uri);

        MultiFileDataParameters p = new MultiFileDataParametersImpl();

        p.setURI(uri);

        super.init(

            p,

            null,

            ToolsLocator.getDynObjectManager().createDynObject(

                MetadataLocator.getMetadataManager().getDefinition(DataStore.METADATA_DEFINITION_NAME)));

        init(p, null);

    }

    /**

     * @param params

     * @param storeServices

     * @throws NotSupportedExtensionException

     * @throws OpenException

     */

    public MultiFileProvider(MultiFileDataParametersImpl 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 params

	 * @param storeServices

	 * @param proj Projection

	 * @param param Load parameters

	 * @throws NotSupportedExtensionException

	 * @throws OpenException

	 */

	public void init(MultiFileDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		openFromMff();

		uri = getParameters().getURI();

		setParam(storeServices, params);

		try {

			setFirstProviderToNotTiled();

		} catch (InvalidSourceException e1) {

			throw new OpenException(e1.getMessage(), e1);

		}

		super.init();

		try {

			loadFromRmf(getRmfBlocksManager());

		} catch (ParsingException e) {

			logger.debug("Problems reading from RMF", e);

		}

		open = true;

	}

	/**

	 * Open from a .mff file.

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

	 * @throws OpenException

	 */

	private void openFromMff() throws OpenException {

		URI uriParam = getParameters().getURI();

        if (uriParam != null) {

            File fileFromUriParam = new File(uriParam);

            if (fileFromUriParam.exists()) {

                boolean loadedProviders = true;

                if (getParameters().hasProviders()) {

                    // solo se considera que est?n todos los providers cargados

                    // si existen y est?n open,

                    // sino se leer?n de disco

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

                        if (!getParameters().getProviders().get(i).isOpen())

                            loadedProviders = false;

                    }

                } else

                    loadedProviders = false;

                if (loadedProviders)

                    return;

                try {

                    if (getParameters().hasProviders())

                        getParameters().removeAllProviders();

                    MultiFileFormat multiFileFormat = new MultiFileFormat();

                    multiFileFormat = MultiFileFormatSerializer.read(multiFileFormat, fileFromUriParam.getAbsolutePath());

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

                                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 .mff can't be read", e1);

                } catch (ParsingException e1) {

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

                }

            }

        }

	}

	/**

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

	}

	/**

	 * Checks if the new file is compatible with the old one

	 * @param file

	 * @return

	 * @throws LocatorException

	 * @throws NotSupportedExtensionException

	 * @throws RasterDriverException

	 * @throws CloseException

	 */

	private boolean checkNewProvider(RasterProvider p) {

		Rectangle2D extentOrigin = getExtent().toRectangle2D();

		Extent extentNewFile = p.getExtent();

		// Comprobamos que el extent y tama�o del fichero a�adido sea igual al

		// fichero original. Si no es as� no abrimos la capa y mostramos un aviso

		double widthNewFile = (extentNewFile.getMax().getX() - extentNewFile.getMin().getX());

		double heightNewFile = (extentNewFile.getMax().getY() - extentNewFile.getMin().getY());

		if ((widthNewFile - extentOrigin.getWidth()) > 1.0 || (widthNewFile - extentOrigin.getWidth()) < -1.0 || (heightNewFile - extentOrigin.getHeight()) > 1.0

				|| (heightNewFile - extentOrigin.getHeight()) < -1.0) {

			return false;

		}

		if ((extentNewFile.getMax().getX() - extentNewFile.getMin().getX()) != extentOrigin.getWidth()

				|| (extentNewFile.getMax().getY() - extentNewFile.getMin().getY()) != extentOrigin.getHeight()) {

			return false;

		}

		return true;

	}

	/**

	 * @return MultiFileDataParameters

	 */

	public MultiFileDataParameters getParameters() {

		try {

			return (MultiFileDataParameters)parameters;

		} catch (ClassCastException e) {

			return null;

		}

	}

	public RasterProvider load() {

		return this;

	}

	public int getBandCount() {

		List<RasterProvider> providerList = getParameters().getProviders();

		int bandCount = 0;

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

			bandCount += providerList.get(i).getBandCount();

		}

		return bandCount;

	}

	public int[] getDataType() {

		List<RasterProvider> providerList = getParameters().getProviders();

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

		int k = 0;

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

			int[] dtByProv = providerList.get(i).getDataType();

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

				datatypes[k] = dtByProv[j];

				k++;

			}

		}

		return datatypes;

	}

	public URI[] getURIByProvider() {

		List<RasterProvider> providerList = getParameters().getProviders();

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

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

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

		}

		return uris;

	}

	public int getBandPositionByProvider(int band) {

		return getSubBandByBandNumber(band)[1];

	}

	public URI getURIOfFirstProvider() {

		List<RasterProvider> providerList = getParameters().getProviders();

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

	}

	public Extent getExtent() {

		List<RasterProvider> providerList = getParameters().getProviders();

		if(providerList != null && providerList.size() > 0)

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

		return null;

	}

	public AffineTransform getAffineTransform() {

		List<RasterProvider> providerList = getParameters().getProviders();

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

	}

	public void setAffineTransform(AffineTransform t) {

		List<RasterProvider> providerList = getParameters().getProviders();

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

			providerList.get(i).setAffineTransform(t);

		}

	}

	public int getInternalProviderCount() {

		return getParameters().getProviders().size();

	}

	public RasterProvider getInternalProvider(int i) {

		return getParameters().getProviders().get(i);

	}

	public int[] getBandCountByProvider() {

		List<RasterProvider> providerList = getParameters().getProviders();

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

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

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

		}

		return bc;

	}

	public long[] getFileSizeByProvider() {

		List<RasterProvider> providerList = getParameters().getProviders();

		long[] fs = new long[providerList.size()];

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

			fs[i] = ((AbstractRasterProvider)providerList.get(i)).getFileSize();

		}

		return fs;

	}

	public Point2D rasterToWorld(Point2D pt) {

		List<RasterProvider> providerList = getParameters().getProviders();

		return providerList.get(0).rasterToWorld(pt);

	}

	public Point2D worldToRaster(Point2D pt) {

		List<RasterProvider> providerList = getParameters().getProviders();

		return providerList.get(0).worldToRaster(pt);

	}

	public boolean isInside(Point2D p){

		List<RasterProvider> providerList = getParameters().getProviders();

		return providerList.get(0).isInside(p);

	}

	public double getCellSize() {

		List<RasterProvider> providerList = getParameters().getProviders();

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

	}

	public Statistics getStatistics() {

		if(stats == null || (stats instanceof MultiProviderStatistics &&

				((MultiProviderStatistics)stats).getNumberOfProviders() != getParameters().getProviders().size())) {

			List<RasterProvider> providerList = getParameters().getProviders();

			stats = new MultiProviderStatistics(providerList, this);

		}

		return stats;

	}

	public HistogramComputer getHistogramComputer() {

		if(histogram == null ||

			(histogram instanceof MultiProviderHistogramComputer &&

			((MultiProviderHistogramComputer)histogram).getNumberOfProviders() != getParameters().getProviders().size())) {

			histogram = new MultiProviderHistogramComputer(this);

		}

		return histogram;

	}

	/**

	 * A multiband provider doesn't have a color table because this will have

	 * more than one band.

	 */

	public ColorTable getColorTable() {

		return null;

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

	}

	public URI translateURI(URI uri) {

		return uri;

	}

	/**

	 * Asigna el extent de la vista actual. existe un fichero .rmf debemos hacer una transformaci�n

	 * de la vista asignada ya que la petici�n viene en coordenadas del fichero .rmf y la vista (v)

	 * ha de estar en coordenadas del fichero.

	 */

	public void setView(Extent e) {

		viewRequest = new ExtentImpl(e);

	}

	public Extent getView() {

		return viewRequest;

	}

	public double getWidth() {

		List<RasterProvider> providerList = getParameters().getProviders();

		if(providerList != null && providerList.size() > 0) {

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

		}

		return 0;

	}

	public double getHeight() {

		List<RasterProvider> providerList = getParameters().getProviders();

		if(providerList != null && providerList.size() > 0) {

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

		}

		return 0;

	}

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

		throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

		return null;

	}

	/**

	 * Gets a number of provider and the band of this provider

	 * @param band

	 * @return

	 */

	private int[] getSubBandByBandNumber(int band) {

		List<RasterProvider> providerList = getParameters().getProviders();

		int[] res = new int[2];

		int acum = 0;

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

			acum += providerList.get(i).getBandCount();

			if(acum > band) {

				res[0] = i;

				int aux = (acum - providerList.get(i).getBandCount());

				res[1] = band - aux;

				return res;

			}

		}

		return res;

	}

	@Override

	public void loadBuffer(SpiRasterQuery q)

			throws ProcessInterruptedException, RasterDriverException {

		List<RasterProvider> providerList = getParameters().getProviders();

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

			SpiRasterQuery query = (SpiRasterQuery)q.clone();

			BandList bandListByFile = createBandListByProvider(q.getBandList(), providerList.get(i));

			query.setBandList(bandListByFile);

			providerList.get(i).getDataSet(q);

		}

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

			DefaultRasterStore store = new DefaultRasterStore();

			store.setProvider(providerList.get(i));

			RasterQuery query = ((DefaultRasterQuery)q).clone();

			BandList bandListByFile = createBandListByProvider(q.getBandList(), providerList.get(i));

			query.set

			try {

				store.query((RasterQuery)q);

			} catch (QueryException e) {

				throw new RasterDriverException("Error in query to the provider " + i, e);

			}

		}*/

	}

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

		int[] sub = getSubBandByBandNumber(band);

		RasterProvider prov = getParameters().getProviders().get(sub[0]);

		return prov.getData(x, y, sub[1]);

	}

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

		throws ProcessInterruptedException, RasterDriverException {

		providerList = getParameters().getProviders();

		DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

		q.setAreaOfInterest(extent);

		q.setBandList(bandList);

		q.setBuffer(rasterBuf);

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

			rasterBuf = ((DefaultRasterProvider)providerList.get(i)).getDataSet(q);

		}

		return rasterBuf;

	}*/

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

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

		providerList = getParameters().getProviders();

		DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

		q.setAreaOfInterest(ulx, uly, w, h);

		q.setBandList(bandList);

		q.setBuffer(rasterBuf);

		q.setAdjustToExtent(adjustToExtent);

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

			rasterBuf = ((DefaultRasterProvider)providerList.get(i)).getDataSet(q);

		}

		return rasterBuf;

	}*/

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

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

		providerList = getParameters().getProviders();

		DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

		q.setAreaOfInterest(extent, bufWidth, bufHeight);

		q.setBuffer(rasterBuf);

		q.setAdjustToExtent(adjustToExtent);

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

			BandList bandListByFile = createBandListByProvider(bandList, providerList.get(i));

			if(bandListByFile != null) {

				q.setBandList(bandListByFile);

				rasterBuf = ((DefaultRasterProvider)providerList.get(i)).getDataSet(q);

			}

		}

		return rasterBuf;

	}*/

	/**

	 * Creates a <code>BandList</code> for each provider of this <code>MultiFileProvider</code>.

	 * When a request is made, the <code>BandList</code> is global for all files. A specific

	 * <code>BandList</code> has to be built for each provider.

	 * @param globalBandList

	 * @param provider

	 * @return

	 */

	private BandList createBandListByProvider(BandList globalBandList, RasterProvider provider) {

		if(provider.isTiled()) {

			//Si los proveedores que hay por debajo son tileados estos crear�n su propio buffer para escribir

			//cada tile. Por ello no usar� el buffer que viene del store. Esto quiere decir que el BandList ha

			//de ser distinto para que escriba bien en su buffer

			//TODO: De momento no se permiten MultiFiles con proveedores tileados. Esto es porque

			//los tiles crean su propio buffer y no escriben en el buffer creado en el Store

		} else {

			BandList bandListByFile = new BandListImpl();

			String pathUriProvider = new File(provider.getURI()).getAbsolutePath();

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

				try {

					bandListByFile.addBand(new DatasetBandImpl(pathUriProvider, i, provider.getDataType()[0], provider.getBandCount()));

				} catch (BandNotFoundInListException e1) {

				}

			}

			boolean areThereBandsToDraw = false;

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

				int[] bandsToDrawByProviderBand = globalBandList.getBufferBandToDraw(pathUriProvider, i);

				if(bandsToDrawByProviderBand != null) {

					areThereBandsToDraw = true;

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

						bandListByFile.getBand(i).addPositionToDrawInBuffer(bandsToDrawByProviderBand[j]);

					}

				}

			}

			if(areThereBandsToDraw)

				return bandListByFile;

		}

		return null;

	}

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

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

		providerList = getParameters().getProviders();

		DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

		q.setAreaOfInterest(x, y, w, h);

		q.setBandList(bandList);

		q.setBuffer(rasterBuf);

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

			rasterBuf = ((DefaultRasterProvider)providerList.get(i)).getDataSet(q);

		}

		return rasterBuf;

	}*/

	public int getBlockSize() {

		return 0;

	}

	public ColorInterpretation getColorInterpretation() {

		if(super.getColorInterpretation() == null) {

			String[] cis = new String[getBandCount()];

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

				if(i == 0)

					cis[i] = ColorInterpretation.GRAY_BAND;

				else

					cis[i] = ColorInterpretation.UNDEF_BAND;

			}

			setColorInterpretation(new DataStoreColorInterpretation(cis));

		}

		return super.getColorInterpretation();

	}

	public DataStoreTransparency getTransparency() {

		if(fileTransparency == null)

			fileTransparency = new DataStoreTransparency(getColorInterpretation());

		return fileTransparency;

	}

	/**

	 * Informa de si el driver ha supersampleado en el �ltimo dibujado. Es el driver el que colocar�

	 * el valor de esta variable cada vez que dibuja.

	 * @return true si se ha supersampleado y false si no se ha hecho.

	 */

	public boolean isSupersampling() {

		return false;

	}

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

		if(band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

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

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

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

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

	public boolean isMultiFile() {

		return true;

	}

	public boolean isOverviewsSupported() {

		return true;

	}

	public boolean isReproyectable() {

		return true;

	}

	public String getProviderName() {

		return NAME;

	}

	public void setStatus(RasterProvider provider) {

		if(provider instanceof MultiFileProvider) {

			//Not implemented yet

		}

	}

	public boolean isTimeSupported() {

		return true;

	}

	public URI getURIByBand(int band) {

		int[] sub = getSubBandByBandNumber(band);

		RasterProvider prov = getParameters().getProviders().get(sub[0]);

		return prov.getURIOfFirstProvider();

	}

	/**

	 * @param file

	 * @throws InvalidSourceException

	 */

	public void addFile(String file) throws InvalidSourceException {

		ProviderServices provServ = RasterLocator.getManager().getProviderServices();

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

		setFirstProviderToNotTiled();

		List<RasterDataParameters> storeParametersList = provServ.createParametersList(file);

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

			RasterProvider newFileProv;

			try {

				newFileProv = (RasterProvider)dataManager.createProvider(storeServices, storeParametersList.get(j));

				if(!newFileProv.isTiled() && checkNewProvider(newFileProv)) {

					getParameters().addProvider(newFileProv);

				}

			} catch (InitializeException e) {

				throw new InvalidSourceException("", e);

			} catch (ProviderNotRegisteredException e) {

				throw new InvalidSourceException("", e);

			}

		}

	}

	private void setFirstProviderToNotTiled() throws InvalidSourceException {

		List<RasterProvider> providerList = getParameters().getProviders();

		if(providerList == null || providerList.size() <= 0 || !providerList.get(0).isTiled())

			return;

		//Si el primer proveedor es tileado se cambia a no tileado

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

		ProviderServices provServ = RasterLocator.getManager().getProviderServices();

		RasterDataParameters firstDataParameters = providerList.get(0).getDataParameters();

		URI uri = firstDataParameters.getURI();

		List<RasterDataParameters> storeParametersList = provServ.createParametersList(new File(uri).getAbsolutePath());

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

			RasterProvider newFileProv;

			try {

				newFileProv = (RasterProvider)dataManager.createProvider(storeServices, storeParametersList.get(j));

				if(!newFileProv.isTiled() && checkNewProvider(newFileProv)) {

					getParameters().setFirstProvider(newFileProv);

				}

			} catch (InitializeException e) {

				throw new InvalidSourceException("Error replacing the first provider", e);

			} catch (ProviderNotRegisteredException e) {

				throw new InvalidSourceException("Error replacing the first provider", e);

			}

		}

	}

	public void removeFile(File file) {

		getParameters().removeProvider(file.toURI());

	}

	public TileServer getTileServer() {

		if(tileServer == null) {

			DefaultRasterStore store = new DefaultRasterStore();

			store.setProvider(this);

			tileServer = new FileTileServer(store);

		}

		return tileServer;

	}

    public void addFile(File file) throws InvalidSourceException {

        ProviderServices provServ = RasterLocator.getManager().getProviderServices();

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

        setFirstProviderToNotTiled();

        List<RasterDataParameters> storeParametersList = provServ.createParametersList(file);

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

            RasterProvider newFileProv;

            try {

                newFileProv = (RasterProvider)dataManager.createProvider(storeServices, storeParametersList.get(j));

                if(!newFileProv.isTiled() && checkNewProvider(newFileProv)) {

                    getParameters().addProvider(newFileProv);

                }

            } catch (InitializeException e) {

                throw new InvalidSourceException("", e);

            } catch (ProviderNotRegisteredException e) {

                throw new InvalidSourceException("", e);

            }

        }

    }

}

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.multifile.io;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

/**

 * Parameters for the Multifile explorer provider

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

 */

public class MultiFileServerExplorerParameters extends AbstractDataServerExplorerParameters implements DataServerExplorerParameters {

	public static final String     DYNCLASS_NAME       = "MultifileServerExplorerParameters";

	protected static DynClass      DYNCLASS            = null;

	private DelegatedDynObject     delegatedDynObject  = null;

	public MultiFileServerExplorerParameters() {

		super();

		initialize();

	}

	protected void initialize() {

		this.delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						DYNCLASS);

	}

	public static void registerDynClass() {

		DynObjectManager dynman = ToolsLocator.getDynObjectManager();

		DynClass dynClass;

		if(dynman == null)

			return;

		if (DYNCLASS == null) {

			dynClass = dynman.add(DYNCLASS_NAME);

			DYNCLASS = dynClass;

		}

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return delegatedDynObject;

	}

	public String getDataStoreName() {

		return MultiFileProvider.NAME;

	}

	public String getDescription() {

		return MultiFileProvider.DESCRIPTION;

	}

	public String getExplorerName() {

		return MultiFileProvider.NAME;

	}

}

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.multifile.io;

import java.net.URI;

import java.util.List;

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

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

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

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

/**

 * Parameters for the Multifile provider

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

 */

public interface MultiFileDataParameters extends RasterDataParameters {

	public static final String            FIELD_PROVIDERS           = "Providers";

	/**

	 * Removes all providers

	 */

	public void removeAllProviders();

	/**

	 * Returns true if this multifile has providers loaded

	 * @return boolean

	 */

	public boolean hasProviders();

	/**

	 * Removes a provider from the list

	 * @param uri

	 */

	public void removeProvider(URI uri);

	/**

	 * Adds a provider to the list if the this is not tiled

	 * @param provider

	 * @param prov

	 */

	public void addProviderNotTiled(DataStoreProvider provider);

	/**

	 * Set the selected provider in the first position

	 * @param provider

	 */

	public void setFirstProvider(DataStoreProvider provider);

	/**

	 * Adds a provider to the list

	 * @param provider

	 * @param prov

	 */

	public void addProvider(DataStoreProvider provider);

	/**

	 * Adds a provider to the list from a RasterDataStore

	 * @param rasterDataStore

	 */

	public void addProvider(RasterDataStore rasterDataStore);

	/**

	 * Gets the list of providers

	 * @return the list of providers

	 */

	public List<RasterProvider> getProviders();

}

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