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.netcdf</artifactId>

	<packaging>pom</packaging>

	<version>2.2.154</version>

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

	<description>NetCDF adapter</description>

	<inceptionYear>2011</inceptionYear>

	<parent>

      <groupId>org.gvsig</groupId>

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

      <version>2.0.346</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.177</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.netcdf/tags/org.gvsig.raster.netcdf-2.2.154</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.netcdf/tags/org.gvsig.raster.netcdf-2.2.154</developerConnection>

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

    </scm>

    <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.netcdf/tags/</tagBase>

                    <goals>deploy</goals>

                </configuration>

            </plugin>

        </plugins>

    </build>

    <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>essi-unidata</groupId>

			  <artifactId>netcdf-java</artifactId>

			  <version>4.2</version>

			</dependency>

			<dependency>

        <groupId>org.gvsig</groupId>

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

        <version>2.2.154</version>

      </dependency>

    	</dependencies>

    </dependencyManagement>

	<modules>

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

		<module>org.gvsig.raster.netcdf.app.netcdfclient</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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.netcdf.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.RemoveException;

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

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

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

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

public class NetCDFFilesystemServerExplorer extends AbstractFilesystemServerExplorerProvider implements FilesystemServerExplorerProvider {

	public static final String NAME       = NetCDFProvider.NAME;

	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 void remove(DataStoreParameters parameters) throws RemoveException {

		throw new UnsupportedOperationException();

	}

	public String getDataStoreProviderName() {

		return NetCDFProvider.NAME;

	}

	public boolean accept(File pathname) {

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

				pathname.getAbsolutePath(), 

				NetCDFProvider.class);

	}

	public String getDescription() {

		return NetCDFProvider.DESCRIPTION;

	}

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		NetCDFDataParameters params = (NetCDFDataParameters) manager

				.createStoreParameters(this.getDataStoreProviderName());

		params.setFile(file);

		return params;

	}

	public int getMode() {

		return DataServerExplorer.MODE_RASTER;

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		// TODO Auto-generated method stub

		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<?> getDataStoreProviderNames() {

		return null;

	}

	public DataServerExplorerParameters getParameters() {

		// TODO Auto-generated method stub

		return null;

	}

	public String getProviderName() {

		return NetCDFProvider.NAME;

	}

	public List<?> list() throws DataException {

		return null;

	}

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

		return null;

	}

	public void dispose() {

	}

}

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

/**

 * Writer for netCDF format

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

 */

public class NetCDFWriter /*extends DefaultRasterWriter*/ {

//	public static void register() {

//		DefaultProviderServices pInfo = (DefaultProviderServices)RasterLocator.getManager().getProviderServices();

//		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

//		ExtensionPoint point = extensionPoints.get("RasterWriter");

//

//		point.append("nc", "", NetCDFWriter.class);

//		WriteFileFormatFeatures features = new WriteFileFormatFeatures("NetCDF", "nc", new int[] { -1 }, new int[] { 0, 1, 2, 3, 4, 5 }, NetCDFWriter.class);

//		pInfo.getFileFeature().put("nc", features);

//	}

//	

//	private boolean							write             = true; //Cuando est? a true se puede escribir en la imagen de salida. Si est? a false el proceso es interrumpido

//	private int 							dataType          = RasterBuffer.TYPE_UNDEFINED;

//	private NetcdfFileWriteable             ncfile            = null; 

//	private String                          bandPrefix        = "band_";

//	/**

//	 * Loads the driver parameters.

//	 */

//	public void loadParams(String ident) {

//		WriteFileFormatFeatures wfff = (WriteFileFormatFeatures)pInfo.getFileFeature().get(ident);

//		wfff.loadParams();

//		driverParams = (ParamsImpl)wfff.getParams();

//	}

//

//	/**

//	 * Constructor para la obtenci?n de par?metros del driver

//	 * @param fileName

//	 */

//	public NetCDFWriter(String fileName) {

//		ident = fileUtil.getExtensionFromFileName(fileName);

//		driver = ((WriteFileFormatFeatures)pInfo.getFileFeature().get(ident)).getDriverName();

//

//		loadParams(ident);

//	}

//

//	/**

//	 * NetCDFWriter constructor

//	 * @param dataWriter       	Objeto servidor de datos para el driver de escritura

//	 * @param outFilename      	Fichero de salida

//	 * @param blockSize        	Tama?o de bloque

//	 * @param Extent           	extent

//	 * @param compresion	   	Compresi?n si la tiene

//	 * @param outSizeX		  	Tama?o de salida en X

//	 * @param outSizeY			Tama?o de salida en Y

//	 * @param dataType			Tipo de dato

//	 * @throws GdalException

//	 * @throws IOException

//	 */

//	public NetCDFWriter (DataServerWriter dataWriter,

//			String outFileName,

//			Integer nBands,

//			AffineTransform at,

//			Integer outSizeX,

//			Integer outSizeY,

//			Integer dataType,

//			Params params,

//			IProjection proj) throws GdalException, IOException {

//		this(dataWriter, outFileName, nBands, at, outSizeX, outSizeY, dataType, params, proj, new Boolean(true));

//	}

//

//	/**

//	 * NetCDFWriter constructor

//	 * @param dataWriter       	Objeto servidor de datos para el driver de escritura

//	 * @param outFilename      	Fichero de salida

//	 * @param blockSize        	Tama?o de bloque

//	 * @param Extent           	extent

//	 * @param compresion	   	Compresi?n si la tiene

//	 * @param outSizeX		  	Tama?o de salida en X

//	 * @param outSizeY			Tama?o de salida en Y

//	 * @param dataType			Tipo de dato

//	 * @param geo				Flag que dice si se salva con georreferenciaci?n o sin ella

//	 * @throws GdalException

//	 * @throws IOException

//	 */

//	public NetCDFWriter (DataServerWriter dataWriter,

//			String outFileName,

//			Integer nBands,

//			AffineTransform at,

//			Integer outSizeX,

//			Integer outSizeY,

//			Integer dataType,

//			Params params,

//			IProjection proj,

//			Boolean geo)throws GdalException, IOException {

//

//		this.proj = proj;

//		ident = outFileName.toLowerCase().substring(outFileName.lastIndexOf(".") + 1);

//		driver = ((WriteFileFormatFeatures)pInfo.getFileFeature().get(ident)).getDriverName();

//		this.dataType = dataType.intValue();

//		this.at = at;

//		percent = 0;

//

//		this.dataWriter = dataWriter;

//		this.outFileName = outFileName;

//

//		this.sizeWindowX = outSizeX.intValue();

//		this.sizeWindowY = outSizeY.intValue();

//

//		if ((sizeWindowX < 0) || (sizeWindowY < 0))

//			throw new IOException("Tama?o del fichero de salida erroneo.");

//

//		this.nBands = nBands.intValue();

//

//		//Calculamos la georeferenciaci?n a partir del extend pasado por el cliente.

//

//		/*LatLonPoint p1 = new LatLonPointImpl(at.getTranslateY(), at.getTranslateX());

//		Point2D p = rasterToWorld(new Point2D.Double(outSizeX, outSizeY), at); 

//		LatLonPoint p2 = new LatLonPointImpl(at.getTranslateY() - p.getY() , at.getTranslateX() + p.getX());

//		boundingBox = new LatLonRect(p1, p2);*/

//		

//		ncfile = NetcdfFileWriteable.createNew(outFileName, false);

//		

//		/*Dimension latDim = ncfile.addDimension("La1", 1);

//		Dimension lonDim = ncfile.addDimension("Lo1", 1);*/

//		

//		Dimension latDim = ncfile.addDimension("y_dim", sizeWindowY);

//		Dimension lonDim = ncfile.addDimension("x_dim", sizeWindowX);

//		

//		ArrayList<Dimension> dims = new ArrayList<Dimension>();

//		dims.add(latDim);

//		dims.add(lonDim);

//		

//		for (int i = 0; i < nBands; i++) {

//			switch(dataType) {

//			case RasterBuffer.TYPE_BYTE:

//				ncfile.addVariable(bandPrefix + i, ucar.ma2.DataType.CHAR, dims);

//				break;

//			case RasterBuffer.TYPE_SHORT:

//				ncfile.addVariable(bandPrefix + i, ucar.ma2.DataType.SHORT, dims);

//				break;

//			case RasterBuffer.TYPE_INT:

//				ncfile.addVariable(bandPrefix + i, ucar.ma2.DataType.INT, dims);

//				break;

//			case RasterBuffer.TYPE_FLOAT:

//				ncfile.addVariable(bandPrefix + i, ucar.ma2.DataType.FLOAT, dims);

//				break;

//			case RasterBuffer.TYPE_DOUBLE:

//				ncfile.addVariable(bandPrefix + i, ucar.ma2.DataType.DOUBLE, dims);

//				break;

//			}

//		}

//		

//		/*String outRmf = outFileName.substring(0, outFileName.lastIndexOf("."));

//		if(geo.booleanValue())

//			rasterUtil.saveGeoInfo(outRmf, at, new Point2D.Double(sizeWindowX, sizeWindowY));*/

//

//		if(params == null)

//			loadParams(ident);

//		else

//			if(params instanceof ParamsImpl)

//				this.driverParams = (ParamsImpl)params;

//	}

//	

//	/**

//	 * Convierte un punto desde coordenadas pixel a coordenadas del mundo.

//	 * @param pt Punto a transformar

//	 * @return punto transformado en coordenadas del mundo

//	 */

//	public Point2D rasterToWorld(Point2D pt, AffineTransform at) {

//		Point2D p = new Point2D.Double();

//		at.transform(pt, p);

//		return p;

//	}

//

//	/**

//	 * Convierte un punto desde del mundo a coordenadas pixel.

//	 * @param pt Punto a transformar

//	 * @return punto transformado en coordenadas pixel

//	 */

//	public Point2D worldToRaster(Point2D pt, AffineTransform at) {

//		Point2D p = new Point2D.Double();

//		try {

//			at.inverseTransform(pt, p);

//		} catch (NoninvertibleTransformException e) {

//			return pt;

//		}

//		return p;

//	}

//	

//	public void setDates(String[] dates) {

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

//			

//		}

//	}

//

//	/**

//	 * A?ade la proyecci?n Wkt con la que salvar.

//	 * @param wkt

//	 * @throws GdalException

//	 */

//	public void setWkt(String wkt) {

//		

//	}

//

//	/**

//	 * Asigna el tipo de driver con el que se salvar? la imagen

//	 * @param drvType        Tipo de driver

//	 */

//	public void setDriverType(String drvType) {

//		this.driver = drvType;

//	}

//

//	

//	/**

//	 * Realiza la funci?n de compresi?n a partir de un GeoRasterFile.

//	 * @throws IOException

//	 */

//	public void fileWrite() throws IOException, ProcessInterruptedException {

//	}

//

//	/**

//	 * Realiza una copia en el formato especificado.

//	 * @throws IOException

//	 */

//	public static void createCopy(GdalDriver driverDst, String dst, String src,

//			boolean bstrict, String[] params) throws IOException, GdalException {

//		if (dst == null || src == null)

//			throw new IOException("No se ha asignado un fichero de entrada.");

//

//		

//	}

//

//	/**

//	 * Realiza la escritura de datos con los datos que le pasa el cliente.

//	 * @throws IOException

//	 * @throws RmfSerializerException

//	 */

//	public void dataWrite() throws IOException, ProcessInterruptedException,

//	OutOfMemoryError {

//		if (ncfile == null)

//			throw new IOException("No se ha obtenido un objeto de entrada para la escritura valido.");

//

//		ncfile.create();

//		int[] origin = new int[2];

//		try {

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

//				switch(dataType) {

//				case RasterBuffer.TYPE_BYTE:

//					ArrayByte b = new ArrayByte.D2(sizeWindowY, sizeWindowX);

//					dataWriter.setBand(iBand);

//					byte[][] valueb = dataWriter.readByteData(sizeWindowX, sizeWindowY);

//					for (int i = 0; i < b.getSize(); i++) {

//						b.setByte(i, valueb[0][i]);

//					}

//					ncfile.write(bandPrefix + iBand, origin, b);

//					break;

//				case RasterBuffer.TYPE_SHORT:

//					ArrayShort s = new ArrayShort.D2(sizeWindowY, sizeWindowX);

//					dataWriter.setBand(iBand);

//					short[][] values = dataWriter.readShortData(sizeWindowX, sizeWindowY);

//					for (int i = 0; i < s.getSize(); i++) {

//						s.setDouble(i, values[0][i]);

//					}

//					ncfile.write(bandPrefix + iBand, origin, s);

//					break;

//				case RasterBuffer.TYPE_INT:

//					ArrayInt in = new ArrayInt.D2(sizeWindowY, sizeWindowX);

//					dataWriter.setBand(iBand);

//					int[][] valuei = dataWriter.readIntData(sizeWindowX, sizeWindowY);

//					for (int i = 0; i < in.getSize(); i++) {

//						in.setDouble(i, valuei[0][i]);

//					}

//					ncfile.write(bandPrefix + iBand, origin, in);

//					break;

//				case RasterBuffer.TYPE_FLOAT:

//					ArrayFloat f = new ArrayFloat.D2(sizeWindowY, sizeWindowX);

//					dataWriter.setBand(iBand);

//					float[][] valuef = dataWriter.readFloatData(sizeWindowX, sizeWindowY);

//					for (int i = 0; i < f.getSize(); i++) {

//						f.setFloat(i, valuef[0][i]);

//					}

//					ncfile.write(bandPrefix + iBand, origin, f);

//					break;

//				case RasterBuffer.TYPE_DOUBLE:

//					ArrayDouble d = new ArrayDouble.D2(sizeWindowY, sizeWindowX);

//					dataWriter.setBand(iBand);

//					double[][] valued = dataWriter.readDoubleData(sizeWindowX, sizeWindowY);

//					for (int i = 0; i < d.getSize(); i++) {

//						d.setDouble(i, valued[0][i]);

//					}

//					ncfile.write(bandPrefix + iBand, origin, d);

//					break;

//				}

//			}

//		} catch (InvalidRangeException e) {

//			new IOException(e.getMessage());

//		}

//	}

//

//

//	/**

//	 * Cancela el salvado de datos.

//	 * @throws GdalException

//	 */

//	public void writeClose() {

//		try {

//			ncfile.close();

//		} catch (IOException e) {

//			e.printStackTrace();

//		}

//	}

//

//	/**

//	 * Cancela el salvado de datos.

//	 */

//	public void writeCancel() {

//		write = false;

//	}

//

//	/**

//	 * Obtiene el valor a la variable write que estar? a true cuando se est? escribiendo

//	 *  o puede escribirse la imagen de salida. El cancelar la operaci?n de escritura

//	 * pondr? esta variable a false deteniendose la escritura y cerrandose el dataset

//	 * de salida.

//	 * @return True si puede escribirse y false si no puede

//	 */

//	public boolean isWrite() {

//		return write;

//	}

//

//	/**

//	 * Asigna el valor a la variable write que estar? a true cuando se est? escribiendo

//	 *  o puede escribirse la imagen de salida. El cancelar la operaci?n de escritura

//	 * pondr? esta variable a false deteniendose la escritura y cerrandose el dataset

//	 * de salida.

//	 * @param write Variable booleana. True si puede escribirse y false si no puede

//	 */

//	public void setWrite(boolean write) {

//		this.write = write;

//	}

//

//	/**

//	 * Asigna los par?metros del driver modificados por el cliente.

//	 * @param Params

//	 */

//	public void setParams(Params params) {

//		if(params instanceof ParamsImpl)

//			this.driverParams = (ParamsImpl)params;

//		else 

//			return;

//	}

}

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

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Date;

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

import ucar.nc2.Variable;

/**

 * Parameters for the NetCDF provider

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

 */

public interface NetCDFDataParameters extends MultiDimensionalStoreParameters {

	public static final String            FIELD_VARIABLE             = "GridVariable";

	public static final String            FIELD_TIME                 = "Time";

	public static final String            FIELD_LEVEL                = "Level";

	public static final String            FIELD_XDIM                 = "XDim";

	public static final String            FIELD_YDIM                 = "YDim";

	/**

	 * Gets the list of grids

	 * @return A list of pair of values. The first element of one pair is the variable's name 

	 * and the second its description

	 * @throws IOException 

	 */

	public ArrayList<Variable> getVariables() throws IOException;

	/**

	 * Gets the list of grids

	 * @return A list of pair of values. The first element of one pair is the variable's name 

	 * and the second its description

	 * @throws IOException 

	 */

	public ArrayList<String[]> getGridVariables() throws IOException;

	/**

	 * Gets the list of dates

	 * @param var

	 * @return

	 */

	public Date[] getTimeList(String var);

	/**

	 * Gets the number of levels of one variable

	 * @param var

	 * @return

	 */

	public double[] getLevelList(String var);

	/**

	 * Gets the variable's name of the X dimension

	 * @return

	 */

	public String getXDimVariable();

	/**

	 * Gets the variable's name of the Y dimension

	 * @return

	 */

	public String getYDimVariable();

	public void selectNextInstant();

	public void selectPrevInstant();

	public void goTo(int position);

	public int getFieldTime();

	/**

	 * Gets the level selected in the list of levels of the selected variable

	 * @return

	 */

	public int getFieldLevel();

	public String getStringVariable();

	public String getStringLevel();

	public String getStringTime();

	public void setFieldVariable(String variable);

	public void setFieldTime(int timePosInList);

	public void setFieldLevel(int levelPosInList);

	public void setFile(File file);

}

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

import java.io.IOException;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import ucar.nc2.Dimension;

import ucar.nc2.NetcdfFile;

import ucar.nc2.Variable;

import ucar.nc2.dataset.CoordinateAxis1D;

import ucar.nc2.dataset.CoordinateAxis1DTime;

import ucar.nc2.dt.GridCoordSystem;

import ucar.nc2.dt.GridDatatype;

import ucar.nc2.dt.grid.GridDataset;

/**

 * Parameters for the NetCDF provider

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

 */

public class NetCDFDataParametersImpl extends AbstractRasterFileDataParameters implements NetCDFDataParameters {

	private ArrayList<String[]>           gridVarList                = null;

	private ArrayList<Variable>           varList                    = null;

	private HashMap<String, double[]>     rankByVar                  = new HashMap<String, double[]>();

	private HashMap<String, Date[]>       dateByVar                  = new HashMap<String, Date[]>();

	private String                        xDimVariable               = null;

	private String                        yDimVariable               = null;

	public NetCDFDataParametersImpl() {

		super();

		initialize();

	}

	protected void initialize() {

		delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						registerDynClass());

	}

	public static DynStruct registerDynClass() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.getDefinition("NetCDFDataParametersImpl_Persistent");

		if( definition == null ) {

			definition = manager.addDefinition(

					NetCDFDataParametersImpl.class,

					"NetCDFDataParametersImpl_Persistent",

					"NetCDFDataParametersImpl Persistent",

					null, 

					null

			);

			AbstractRasterFileDataParameters.registerDynClass(definition);

		}

		definition.addDynFieldString(FIELD_VARIABLE)

		.setDescription("Grid variable")

		.setMandatory(false);

		definition.addDynFieldInt(FIELD_LEVEL)

		.setDescription("Level selected")

		.setMandatory(false);

		definition.addDynFieldInt(FIELD_TIME)

		.setDescription("Time selected")

		.setMandatory(false);

		definition.addDynFieldString(FIELD_XDIM).

		setMandatory(false);

		definition.addDynFieldString(FIELD_YDIM).

		setMandatory(false);

		return definition;

	}

	/**

	 * Gets the list of grids

	 * @return A list of pair of values. The first element of one pair is the variable's name 

	 * and the second its description

	 * @throws IOException 

	 */

	public ArrayList<Variable> getVariables() throws IOException {

		if(varList == null) {

			NetcdfFile netCDFFile = NetcdfFile.open(getFile().getAbsolutePath());

			varList = new ArrayList<Variable>();

			List<Variable> variableList = netCDFFile.getVariables();

            Iterator<Variable> it = variableList.iterator();

            while(it.hasNext()) {

            	Variable var = it.next();

            	varList.add(var);

            }

            netCDFFile.close();

		}

		return varList;

	}

	/**

	 * Gets the list of grids

	 * @return A list of pair of values. The first element of one pair is the variable's name 

	 * and the second its description

	 * @throws IOException 

	 */

	public ArrayList<String[]> getGridVariables() throws IOException {

		if(gridVarList == null) {

			GridDataset connector = GridDataset.open(getFile().getAbsolutePath());

			List<GridDatatype> gridList = connector.getGrids();

			gridVarList = new ArrayList<String[]>();

			Iterator<GridDatatype> it = gridList.iterator();

			while(it.hasNext()) {

				GridDatatype dt = it.next();

				//Loads name and description

				String[] pair = new String[2];

				pair[0] = dt.getName();

				pair[1] = dt.getDescription();

				gridVarList.add(pair);

				//Loads variable's name

				Dimension dim = dt.getDimensions().get(dt.getXDimensionIndex());

				xDimVariable = dim.getName();

				dim = dt.getDimensions().get(dt.getYDimensionIndex());

				yDimVariable = dim.getName();

				if(dt.getShape() != null) {

					GridCoordSystem gcs = dt.getCoordinateSystem();

					//Loads levels

					CoordinateAxis1D zAxis = gcs.getVerticalAxis();

					if(zAxis != null) {

						double[] d = calcSliceValue(zAxis.getCoordEdges());

						rankByVar.put(pair[0], d);

					}

					//Loads time list

					if (gcs.hasTimeAxis1D()) {

						CoordinateAxis1DTime tAxis1D = gcs.getTimeAxis1D();

						Date[] dates = tAxis1D.getTimeDates();

						dateByVar.put(pair[0], dates);

					}

				}

			}

			connector.close();

		}

		return gridVarList;

	}

	/**

	 * Calculates the array of levels

	 * @param coordsEdges

	 * @return

	 */

	private double[] calcSliceValue(double[] coordsEdges) {

		if(coordsEdges == null)

			return null;

		double[] values = new double[coordsEdges.length - 1];

		for (int i = 0; i < coordsEdges.length - 1; i++) {

			values[i] = ((coordsEdges[i] + coordsEdges[i + 1]) / 2);

		}

		return values;

	}

	/**

	 * Gets the list of dates

	 * @param var

	 * @return

	 */

	public Date[] getTimeList(String var) {

		return dateByVar.get(var);

	}

	/**

	 * Gets the number of levels of one variable

	 * @param var

	 * @return

	 */

	public double[] getLevelList(String var) {

		return rankByVar.get(var);

	}

	/**

	 * Gets the variable's name of the X dimension

	 * @return

	 */

	public String getXDimVariable() {

		return xDimVariable;

	}

	/**

	 * Gets the variable's name of the Y dimension

	 * @return

	 */

	public String getYDimVariable() {

		return yDimVariable;

	}

	public String getDataStoreName() {

		return NetCDFProvider.NAME;

	}

	public String getDescription() {

		return NetCDFProvider.DESCRIPTION;

	}

	public void selectNextInstant() {

		int i = getFieldTime() + 1;

		if(i < getTimeListLength()) {

			setDynValue(NetCDFDataParameters.FIELD_TIME, i);

		}

	}

	public void selectPrevInstant() {

		int i = getFieldTime() - 1;

		if(i >= 0) {

			setDynValue(NetCDFDataParameters.FIELD_TIME, i);

		}

	}

	public void goTo(int position) {

		if(position < getTimeListLength() && position >= 0) {

			setDynValue(NetCDFDataParameters.FIELD_TIME, position);

		}

	}

	public int getFieldTime() {

		if(hasDynValue(NetCDFDataParameters.FIELD_TIME) && getDynValue(NetCDFDataParameters.FIELD_TIME) != null) {

			return ((Integer)getDynValue(NetCDFDataParameters.FIELD_TIME)).intValue();

		}

		return 0;

	}

	public int getFieldLevel() {

		if(hasDynValue(NetCDFDataParameters.FIELD_LEVEL) && getDynValue(NetCDFDataParameters.FIELD_LEVEL) != null) {

			return ((Integer)getDynValue(NetCDFDataParameters.FIELD_LEVEL)).intValue();

		}

		return 0;

	}

	public String getStringVariable() {

		if(hasDynValue(NetCDFDataParameters.FIELD_VARIABLE)) {

			return (String)getDynValue(NetCDFDataParameters.FIELD_VARIABLE);

		}

		//We will use the first variable in the list

		try {

			ArrayList<String[]> vars = getGridVariables();

			if(vars.size() > 0) {

				String[] var = vars.get(0);

				if(var.length > 0) {

					setFieldVariable(var[0]); 

					return var[0];

				}

			}

		} catch (IOException e) {

			e.printStackTrace();

		}

		return null;

	}

	public String getStringLevel() {

		if(!hasDynValue(NetCDFDataParameters.FIELD_LEVEL)) {

			//We will use the first level in the list

			setFieldLevel(0);

		}

		int index = ((Integer)getDynValue(NetCDFDataParameters.FIELD_LEVEL)).intValue();

		double[] levelList = getLevelList(getStringVariable());

		if(levelList == null)

			return "-1";

		return levelList[index] + "";

	}

	public String getStringTime() {

		if(!hasDynValue(NetCDFDataParameters.FIELD_TIME)) {

			setFieldTime(0);

		}

		int index = ((Integer)getDynValue(NetCDFDataParameters.FIELD_TIME)).intValue();

		Date[] timeList = getTimeList(getStringVariable());

		if(timeList == null)

			return "-1";

		return timeList[index].toString();

	}

	/**

	 * Gets the length of the time list

	 * @return

	 */

	private int getTimeListLength() {

		String var = (String)getDynValue(NetCDFDataParameters.FIELD_VARIABLE);

		if(var != null) {

			Date[] dateList = getTimeList(var);

			if(dateList != null)

				return dateList.length;

		}

		return 0;

	}

	public void setFieldVariable(String variable) {

		setDynValue(NetCDFDataParameters.FIELD_VARIABLE, variable);

	}

	public void setFieldTime(int timePosInList) {

		setDynValue(NetCDFDataParameters.FIELD_TIME, timePosInList);

	}

	public void setFieldLevel(int levelPosInList) {

		setDynValue(NetCDFDataParameters.FIELD_LEVEL, levelPosInList);

	}

}

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

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 *

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

 */

public class DefaultNetCDFIOLibrary extends AbstractLibrary {	

	@Override

	protected void doInitialize() throws LibraryException {

		//RasterLibrary.wakeUp();

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		//NetCDFServerExplorerParameters.registerDynClass();

		NetCDFDataParametersImpl.registerDynClass();

		NetCDFProvider.register();

		//NetCDFWriter.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.netcdf.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.coverage.RasterLocator;

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

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

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

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

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

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

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

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

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

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

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

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

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.tools.ToolsLocator;

import ucar.ma2.Array;

import ucar.ma2.DataType;

import ucar.ma2.InvalidRangeException;

import ucar.ma2.Range;

import ucar.nc2.dt.GridDatatype;

import ucar.nc2.dt.grid.GridDataset;

import ucar.unidata.geoloc.ProjectionRect;

/**

 * Data provider for NetCDF files with raster data

 *

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

 */

public class NetCDFProvider extends AbstractRasterProvider {

	public static String                     NAME                     = "NetCDF Raster";

	public static String                     DESCRIPTION              = "NetCDF Raster file";

	public final String                      METADATA_DEFINITION_NAME = NAME;

	private Extent                           viewRequest              = null;

	private TileServer                       tileServer               = null;

	private boolean                          open                     = false;

    private GridDataset                      gridNetCDF               = null;

    private List<GridDatatype>               gridList                 = null;

    private GridDatatype                     selectedGridDataType     = null;

    private DataStoreTransparency            fileTransparency         = null;

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

    protected static String[]                formatList               = null;

	public static void register() {

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

		RasterLocator.getManager().getProviderServices().registerFileProvidersTiled(NetCDFProvider.class);

		registerFormats();

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

			dataman.registerStoreProvider(NAME,

					NetCDFProvider.class, NetCDFDataParametersImpl.class);

		}

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

			dataman.registerExplorerProvider(NetCDFFilesystemServerExplorer.NAME, NetCDFFilesystemServerExplorer.class, NetCDFServerExplorerParameters.class);

		}*/

		if(DALFileLocator.getFilesystemServerExplorerManager() != null)

			DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

					NAME, DESCRIPTION,

					NetCDFFilesystemServerExplorer.class);

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	private static void registerFormats() {

		formatList      = new String[] {"nc", "nc4"};

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

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

	}

	public String[] getFormatList() {

		return formatList;

	}

	/**

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

	 * @param ext

	 * @return

	 */

	public boolean isExtensionSupported(String ext) {

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

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

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

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

				return true;

		}

		return false;

	}

	public NetCDFProvider() {

	}

	/**

	 * Opens the dataset.

	 * @param proj Projection

	 * @param fName File name

	 * @throws NotSupportedExtensionException

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

	 */

	public NetCDFProvider(String params) throws NotSupportedExtensionException, OpenException {

		super(params);

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

		if(params instanceof String) {

			NetCDFDataParameters p = new NetCDFDataParametersImpl();

			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 NetCDFProvider(URI uri) throws NotSupportedExtensionException, OpenException {

        super(uri);

        NetCDFDataParameters p = new NetCDFDataParametersImpl();

        p.setURI(uri);

        super.init(

            p,

            null,

            ToolsLocator.getDynObjectManager().createDynObject(

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

        init(p, null);

    }

    public NetCDFProvider (NetCDFDataParameters 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 (NetCDFDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		if(((RasterFileStoreParameters)params).getFile().exists()) {

			String fileName = ((RasterFileStoreParameters)params).getFile().getAbsolutePath();

            try {

            	gridNetCDF = GridDataset.open(fileName);

            	gridList = gridNetCDF.getGrids();

            	if(gridList.size() == 0)

            		throw new OpenException("There is not a grid variable", null);

            	selectedGridDataType = gridList.get(0);

                //netCDFFile = NetcdfFile.open(((RasterFileStoreParameters)params).getFile().getAbsolutePath());

            } catch (IOException e) {

                throw new OpenException("Imposible to read the file", e);

            }

            /*List<Variable> variableList = netCDFFile.getVariables();

            Iterator<Variable> it = variableList.iterator();

            while(it.hasNext()) {

            	Variable var = it.next();

            	System.out.println("===>>" + var.getName());

            }*/

			setParam(storeServices, params);

			reloadMetadataFromGrid();

			noData = new DefaultNoData(Double.NaN, Double.NaN, fileName);

			load();

		} else

			setParam(storeServices, params);

		super.init();

		selectSubdataset(getId(0, 0, 0));

		try {

			loadFromRmf(getRmfBlocksManager());

		} catch (ParsingException e) {

			//No lee desde rmf

		}

		open = true;

	}

	/**

	 * Reloads metadata using the selected grid

	 */

	private void reloadMetadataFromGrid() {

		//wktProjection = null;

		//CrsWkt crs = new CrsWkt(wktProjection);

		//IProjection proj = CRSFactory.getCRS("EPSG:23030");

		/*LatLonRect gcs = selectedGridDataType.getCoordinateSystem().getLatLonBoundingBox();

		getColorInterpretation();

		double scaleX = gcs.getWidth() / selectedGridDataType.getXDimension().getLength();

		double scaleY = gcs.getHeight() / selectedGridDataType.getYDimension().getLength();

		ownTransformation = new AffineTransform(

				scaleX, 0,

				0, -scaleY,

				gcs.getLonMin(),

				gcs.getLatMax());*/

		ProjectionRect pRect = selectedGridDataType.getCoordinateSystem().getBoundingBox();

		double scaleX = pRect.getWidth() / selectedGridDataType.getXDimension().getLength();

		double scaleY = pRect.getHeight() / selectedGridDataType.getYDimension().getLength();

		ownTransformation = new AffineTransform(

				scaleX, 0,

				0, -scaleY,

				pRect.getMinX(),

				pRect.getMaxY());

		externalTransformation = (AffineTransform)ownTransformation.clone();

		bandCount = 1; //One variable is always shown

		setDataType();

	}

	/**

	 * @param dataType The dataType to set.

	 */

	private void setDataType() {

		DataType dt = selectedGridDataType.getDataType();

		int type = Buffer.TYPE_UNDEFINED;

		if(dt.name() == DataType.BYTE.name()) {

			type = Buffer.TYPE_BYTE;

		}

		if(dt.name() == DataType.SHORT.name()) {

			type = Buffer.TYPE_SHORT;

		}

		if(dt.name() == DataType.INT.name()) {

			type = Buffer.TYPE_INT;

		}

		if(dt.name() == DataType.DOUBLE.name()) {

			type = Buffer.TYPE_DOUBLE;

		}

		if(dt.name() == DataType.FLOAT.name()) {

			type = Buffer.TYPE_FLOAT;

		}

		if(dt.name() == DataType.LONG.name()) {

			type = Buffer.TYPE_DOUBLE;

		}

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

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

			dtype[i] = type;

		setDataType(dtype);

	}