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.23</version>

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

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

	<inceptionYear>2013</inceptionYear>

	<parent>

      <groupId>org.gvsig</groupId>

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

      <version>2.0.123</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.34</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.23</connection>

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

        <url>https://devel.gvsig.org/redmine/projects/gvsig-raster/repository/show/org.gvsig.raster.multifile/tags/org.gvsig.raster.multifile-2.2.23</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.23</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 org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.tools.ToolsLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.Library;

import org.gvsig.tools.library.LibraryException;

/**

 *

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

 */

public class DefaultMultiFileIOLibrary extends AbstractLibrary {	

	@SuppressWarnings("deprecation")

	public DefaultMultiFileIOLibrary() {

		super(DefaultMultiFileIOLibrary.class,Library.TYPE.IMPL);

		require(ToolsLibrary.class);

		require(DALLibrary.class);

		require(DALFileLibrary.class);

	}

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		MultiFileServerExplorerParameters.registerDynClass();

		MultiFileDataParametersImpl.registerDynClass();

		MultiFileProvider.register();

	}

}

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

import java.io.IOException;

import java.io.Reader;

import java.io.StringReader;

import java.text.ParseException;

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

import org.gvsig.raster.impl.store.rmf.ClassSerializer;

import org.gvsig.raster.impl.store.rmf.RmfBlocksManager;

import org.kxml2.io.KXmlParser;

import org.xmlpull.v1.XmlPullParserException;

/**

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

 */

public class MultiFileFormatSerializer extends ClassSerializer {

	//TAGS

	public static final String MAIN_TAG          = "MultiFileFormat";

	public static final String URIS              = "URIs";

	public static final String URI               = "URI";

	public static final String NAME              = "Name";

	private MultiFileFormat   multiFileFormat    = null;

	public MultiFileFormatSerializer(MultiFileFormat timeSeriesFormat) {

		this.multiFileFormat = timeSeriesFormat;

	}

 	/**

	 * Parsers a date list

	 * @param tInfo

	 * @param parser

	 * @param xml

	 * @param tag

	 * @throws XmlPullParserException

	 * @throws IOException

	 * @throws ParsingException

	 * @throws NumberFormatException

	 * @throws ParseException 

	 */

	public void parseURIs(KXmlParser parser, String xml, String parseableTag) throws XmlPullParserException, IOException, NumberFormatException, ParsingException, ParseException  {

		boolean end = false;

		boolean init = false;

		boolean readFile = false;

		int tag = parser.next();

		while (!end) {

			switch (tag) {

				case KXmlParser.END_DOCUMENT:

					return;

				case KXmlParser.START_TAG:

					if (parser.getName().compareTo(parseableTag) == 0) {

						init = true;

					}

					if(init) {

						if (parser.getName().compareTo(URI) == 0) {

							readFile = true;

						}

					}

					break;

				case KXmlParser.END_TAG:

					if (parser.getName().compareTo(parseableTag) == 0)

						end = true;

					break;

				case KXmlParser.TEXT:

					if(readFile) {

						String file = parser.getText();

						multiFileFormat.addFile(new File(file));

						readFile = false;

					}

					break;

			}

			if (!end)

				tag = parser.next();

		}

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.dataset.io.rmf.IRmfBlock#read(java.lang.String)

	 */

	public void read(String xml) throws ParsingException {

		if(multiFileFormat == null)

			multiFileFormat = new MultiFileFormat();

		else {

			multiFileFormat.clean();

		}

		boolean init = false;

		boolean end = false;

		KXmlParser parser = new KXmlParser();

		Reader reader = new StringReader(xml);

		try {

			parser.setInput(reader);

		} catch (XmlPullParserException e) {

			throw new ParsingException(xml);

		}

		try {

			int tag = parser.nextTag();

			if ( parser.getEventType() != KXmlParser.END_DOCUMENT ){

				parser.require(KXmlParser.START_TAG, null, MAIN_TAG);

				while(tag != KXmlParser.END_DOCUMENT) {

					switch(tag) {

						case KXmlParser.START_TAG:

							if (parser.getName().compareTo(MAIN_TAG) == 0)

								init = true;

							break;

						case KXmlParser.END_TAG:

							if(parser.getName().compareTo(MAIN_TAG) == 0)

								end = true;

							break;

						case KXmlParser.TEXT:

							if(init) {

								String name = parserString(parser, NAME, null);

								multiFileFormat.setName(name);

								parseURIs(parser, xml, URIS);

								init = false;

							}

							break;

					}

					if(end)

						break;

					tag = parser.next();

				}

			}

		} catch (XmlPullParserException e) {

			throw new ParsingException(xml);

		} catch (IOException e) {

			throw new ParsingException(xml);

		} catch (NumberFormatException e) {

			throw new ParsingException(xml);

		} catch (ParseException e) {

			throw new ParsingException(xml);

		}

	}

	/**

	 * Writes a MultiFileFormat to disk

	 * @param multiFileFormat

	 * @param file

	 * @throws IOException

	 */

	public static void write(MultiFileFormat multiFileFormat, String fileName) throws IOException {

		File file = new File(fileName);

		file.createNewFile();

		FileWriter writer = new FileWriter(file);

		MultiFileFormatSerializer serializer = new MultiFileFormatSerializer(multiFileFormat);

		writer.write(serializer.write());

		writer.close();

	}

	/**

	 * Reads a TimeSeriesFormat from disk

	 * @param timeSeriesFormat

	 * @param file

	 * @throws IOException

	 * @throws ParsingException 

	 */

	public static MultiFileFormat read(MultiFileFormat timeSeriesFormat, String file) throws IOException, ParsingException {

		RmfBlocksManager manager = new RmfBlocksManager(file);

		MultiFileFormatSerializer serializer = new MultiFileFormatSerializer(timeSeriesFormat);

		manager.addClient(serializer);

		manager.read(null);

		return timeSeriesFormat;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.dataset.io.rmf.IRmfBlock#write()

	 */

	public String write() {

		StringBuffer b = new StringBuffer();

		b.append("<?xml version=\"1.0\" encoding=\"ISO-8859-15\"?>\n");

		b.append("<" + MAIN_TAG + ">\n");

		putProperty(b, NAME, multiFileFormat.getName(), 2);

		b.append("\t\t<" + URIS + ">\n");

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

			putProperty(b, URI, multiFileFormat.getPathToFile(i), 3);

		}

		b.append("\t\t</" + URIS + ">\n");

		b.append("</" + MAIN_TAG + ">\n");

		return b.toString();

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.dataset.io.rmf.IRmfBlock#getResult()

	 */

	public Object getResult() {

		return multiFileFormat;

	}

	/*

	 *  (non-Javadoc)

	 * @see org.gvsig.raster.dataset.io.rmf.IRmfBlock#getMainTag()

	 */

	public String getMainTag() {

		return MAIN_TAG;

	}

}

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

import java.util.List;

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

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

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

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

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

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

/**

 * Explorer for a Multifile 

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

 */

public class MultiFileServerExplorer extends AbstractFilesystemServerExplorerProvider implements DataServerExplorerProvider  {

	public MultiFileServerExplorer() {

	}

	public MultiFileServerExplorer(

			MultiFileServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

		System.out.println();

	}

	public String getDataStoreProviderName() {

		return MultiFileProvider.NAME;

	}

	public String getDescription() {

		return MultiFileProvider.DESCRIPTION;

	}

	public DataStoreParameters getStoreParameters() {

		DataManager manager = DALLocator.getDataManager();

		try {

			return  manager.createStoreParameters(this.getDataStoreProviderName());

		} catch (InitializeException e) {

			e.printStackTrace();

		} catch (ProviderNotRegisteredException e) {

			e.printStackTrace();

		}

		return null;

	}

	public List<?> getDataStoreProviderNames() {

		return null;

	}

	public String getProviderName() {

		return MultiFileProvider.NAME;

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

	public boolean canCreate() {

		return false;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

		return false;

	}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		throw new UnsupportedOperationException();

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		return null;

	}

	public void initialize(

			FilesystemServerExplorerProviderServices serverExplorer) {

	}

	public boolean accept(File pathname) {

		return RasterLocator.getManager().getProviderServices().isExtensionSupported(

				pathname.getAbsolutePath(), 

				MultiFileProvider.class);

	}

	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 DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		AbstractRasterFileDataParameters params = (AbstractRasterFileDataParameters) manager

				.createStoreParameters(this.getDataStoreProviderName());

		params.setFile(file);

		return params;

	}

	public DataServerExplorerParameters getParameters() {

		return null;

	}

	public List<?> list() throws DataException {

		return null;

	}

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

		return null;

	}

	public void dispose() {

	}

	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

	 */

	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

	 */

	public int getNumberOfFiles() {

		return fileList.size();

	}

	/**

	 * Gets the path of the file in the selected position

	 * @param file

	 * @return

	 */

	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;

	}

	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 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 proj Projection

	 * @param fName File name

	 * @throws NotSupportedExtensionException

     * @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 proj Projection

     * @param fName File name

     * @throws NotSupportedExtensionException

     */

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

    }

    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 proj Projection

	 * @param param Load parameters

	 * @throws NotSupportedExtensionException

	 */

	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;

	}

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