Application: gvSIG desktop » gvSIG raster

<project name="org.gvsig.initial.build" default="prepare-workspace">

	<dirname property="org.gvsig.initial.build.basedir" file="${ant.file.org.gvsig.initial.build}" />

	<property name="workspace.basedir" value="${org.gvsig.initial.build.basedir}/.." />

	<property name="build.basedir" value="${workspace.basedir}/org.gvsig.maven.base.build" description="Eclipse workspace location" />

	<property name="build.jar.version" value="1.0.8-SNAPSHOT" />

	<property name="build.jar.file" value="org.gvsig.maven.base.build-${build.jar.version}.jar" />

	<property name="ant.libs.dir" location="${build.basedir}" description="Additional ant tasks libs folder" />

	<target name="check-maven-base-build-available">

		<available file="${user.home}/.m2/repository/org/gvsig/org.gvsig.maven.base.build/${build.jar.version}/${build.jar.file}" property="maven-base-build-available" />

	</target>

	<target name="get-maven-base-build-local" depends="check-maven-base-build-available" if="maven-base-build-available">

		<!-- Unzip de build jar file from the maven repository into the workspace root folder -->

		<copy todir="${workspace.basedir}" preservelastmodified="false" filtering="false">

			<zipfileset src="${user.home}/.m2/repository/org/gvsig/org.gvsig.maven.base.build/${build.jar.version}/${build.jar.file}">

				<patternset>

					<exclude name="META-INF/**" />

				</patternset>

			</zipfileset>

		</copy>

	</target>

	<target name="get-maven-base-build-remote" depends="check-maven-base-build-available" unless="maven-base-build-available">

		<mkdir dir="target" />

		<!-- Download the build jar file -->

		<get src="http://devel.gvsig.org/m2repo/j2se/org/gvsig/org.gvsig.maven.base.build/${build.jar.version}/${build.jar.file}" dest="target/${build.jar.file}" verbose="true" />

		<!-- Unzip de build jar file into the workspace root folder -->

		<copy todir="${workspace.basedir}" preservelastmodified="false" filtering="false">

			<zipfileset src="target/${build.jar.file}">

				<patternset>

					<exclude name="META-INF/**" />

				</patternset>

			</zipfileset>

		</copy>

	</target>

	<target name="find.depends.natives.file">

	    <condition property="depends.natives.file.exists">

            <available file="${org.gvsig.initial.build.basedir}/DEPENDS_ON_NATIVE_LIBRARIES"/>

	    </condition>	

	</target>

	<target name="find.gvsig.platform.properties.file" 

			depends="find.depends.natives.file"

			if="depends.natives.file.exists">

	    <condition property="gvsig.platform.exists">

            <available file="${user.home}/.gvsig.platform.properties"/>

	    </condition>	

	</target>

	<target name="check.gvsig.platform.properties" 

			depends="find.gvsig.platform.properties.file">

		<fail if="depends.natives.file.exists" unless="gvsig.platform.exists">

ERROR!!

You have to define your gvSIG platform properties, 

by creating the file: ${user.home}/.gvsig.platform.properties

with the following content:

native_platform=linux

native_distribution=all

native_compiler=gcc4

native_arch=i386

native_libraryType=dynamic

export native_classifier=${native_platform}-${native_distribution}-${native_compiler}-${native_arch}-${native_libraryType}

Replace the fifth initial variables values with the ones appropiate 

to your platform.

If you use maven in the command line, you can use the previous file also

to define the MAVEN_OPTS environment variable, by adding to your 

.bash_rc file something like this:

if [ -f "${HOME}/.gvsig.platform.properties" ]

then

    . ${HOME}/.gvsig.platform.properties

    export MAVEN_OPTS="-Xmx256M -XX:MaxPermSize=64m -Dnative-classifier=${native_classifier}"

else

    export MAVEN_OPTS="-Xmx256M -XX:MaxPermSize=64m"

fi

It will work if you use the bash shell. In any other case or platform, you'll

have to define your MAVEN_OPTS environment variable and set the 

"native-classifier" parameter directly.

		</fail>			

	</target>

	<target name="prepare-workspace" depends="get-maven-base-build-local,get-maven-base-build-remote,check.gvsig.platform.properties">

		<mkdir dir="target" />

		<chmod dir="${build.basedir}/maven/bin" perm="u+x" includes="m2,mvn,mvnDebug" />

		<!-- Copy the maven launchers to the workspace metadata folder -->

		<copy todir="${workspace.basedir}/.metadata">

			<fileset dir="${build.basedir}/eclipse-launchers">

				<exclude name="**/org.eclipse.jdt.core.prefs" />

				<exclude name="**/org.eclipse.core.variables.prefs" />

			</fileset>

		</copy>

		<concat destfile="${workspace.basedir}/.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.jdt.core.prefs" append="true">

			<filelist dir="${build.basedir}/eclipse-launchers/.plugins/org.eclipse.core.runtime/.settings" files="org.eclipse.jdt.core.prefs" />

		</concat>

		<concat destfile="${workspace.basedir}/.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.core.variables.prefs" append="true">

			<filelist dir="${build.basedir}/eclipse-launchers/.plugins/org.eclipse.core.runtime/.settings" files="org.eclipse.core.variables.prefs" />

		</concat>

		<!-- Configure the eclipse workspace -->

		<ant antfile="${build.basedir}/maven-goals.xml" target="mvn-configure-eclipse-workspace" />

		<!-- Configure the gvSIG profile -->

		<ant antfile="${build.basedir}/check-gvsig-profile.xml" />

		<property name="user-settings-file-location" value="${user.home}/.m2/settings.xml" />

		<taskdef name="xmltask" classname="com.oopsconsultancy.xmltask.ant.XmlTask">

			<classpath>

				<pathelement location="${ant.libs.dir}/com.oopsconsultancy.xmltask-1.16.1.jar" />

			</classpath>

		</taskdef>

		<xmltask source="${user-settings-file-location}" dest="${user-settings-file-location}">

			<copy path="//:settings/:profiles/:profile[:id/text() = 'gvsig-install']/:properties/:gvsig.install.dir/text()" property="current-gvsig-location" />

		</xmltask>

		<replace file="${workspace.basedir}/.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.jdt.core.prefs" token="@GVSIG_HOME@" value="${current-gvsig-location}" />

		<replace file="${workspace.basedir}/.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.core.variables.prefs" token="@GVSIG_HOME@" value="${current-gvsig-location}" />

		<!-- Compile, install and generate eclipse projects -->

		<ant antfile="${build.basedir}/maven-goals.xml" target="mvn-install-and-eclipse-eclipse" />

		<echo>INFORMATION!!!</echo>

		<echo>Restart eclipse and then proceed to import the subprojects contained into the main project</echo>

		<!-- TODO: copiar al proyecto de configuración general -->

	</target>

	<target name="clean">

		<delete dir="target" />

	</target>

</project>

<?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.1</version>

	<name>org.gvsig.raster.netcdf</name>

	<description>NetCDF adapter</description>

	<inceptionYear>2011</inceptionYear>

	<parent>

      <groupId>org.gvsig</groupId>

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

      <version>2.0.25</version>

    </parent>

    <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/v2.2.1</connection>

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

        <url>https://devel.gvsig.org/redmine/projects/gvsig-raster/repository/show/org.gvsig.raster.netcdf/tags/v2.2.1</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>essi-unidata</groupId>

				<artifactId>netcdf-java</artifactId>

				<version>4.2</version>

			</dependency>

			<dependency>

				<groupId>org.gvsig</groupId>

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

				<version>2.2.1</version>

			</dependency>

	        <dependency>

	            <groupId>org.gvsig</groupId>

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

	            <version>2.2.1</version>

	        </dependency>

	        <dependency>

				<groupId>org.gvsig</groupId>

				<artifactId>org.gvsig.raster.cache.lib.api</artifactId>

				<version>2.2.0</version>

			</dependency>

			<!--<dependency>

				<groupId>org.gvsig</groupId>

				<artifactId>org.gvsig.jproj</artifactId>

				<version>2.0.1-SNAPSHOT</version>

				<classifier>${native_classifier}</classifier>

				<type>tar.gz</type>

			</dependency>-->

		    <dependency>

				<groupId>org.gvsig</groupId>

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

				<version>2.2.1</version>

			</dependency>

			<dependency>

	            <groupId>org.gvsig</groupId>

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

	            <version>2.2.1</version>

	        </dependency>

    	</dependencies>

    </dependencyManagement>

	<modules>

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

		<module>org.gvsig.raster.netcdf.app.netcdfclient</module>

	</modules>

</project>

org.gvsig.raster.netcdf.io.DefaultNetCDFIOLibrary

/* 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 org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectManager;

/**

 * Parameters for the NetCDF explorer

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

 */

public class NetCDFServerExplorerParameters extends FilesystemServerExplorerParameters

implements DataServerExplorerParameters {

	public static final String            PARAMS_NAME         = "NetCDFRasterServerExplorerParameters";

	protected static DynClass             DYNCLASS            = null;

	private static final String           FIELD_ROOT          = "root";

	private static DelegatedDynObject     delegatedDynObject  = null;

	public NetCDFServerExplorerParameters() {

		super();

		initialize();

	}

	protected void initialize() {

		delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						DYNCLASS);

	}

	public static DynClass registerDynClass() {

		DynObjectManager dynman = ToolsLocator.getDynObjectManager();

		DynClass dynClass = dynman.get(PARAMS_NAME);

		DynField field;

		if (dynClass == null) {

			dynClass = dynman.add(PARAMS_NAME);

			field = dynClass.addDynFieldString(FIELD_ROOT);

            field.setDescription("Root directory path of the explorer");

            field.setMandatory(false);

            field.setClassOfValue(String.class); 

			field = dynClass.addDynFieldString("initialpath");

            field.setDescription("Initial path of the explorer");

            field.setMandatory(false);

            field.setClassOfValue(String.class);

            DYNCLASS = dynClass;

		}

		return dynClass;

	}

	public void setRoot(String path) {

		this.setDynValue(FIELD_ROOT, path);

	}

	public String getRoot() {

		return (String) this.getDynValue(FIELD_ROOT);

	}

	public void setInitialpath(String path) {

		this.setDynValue("initialpath", path);

	}

	public String getInitialpath() {

		return (String) this.getDynValue("initialpath");

	}

	public String getExplorerName() {

		return NetCDFFilesystemServerExplorer.NAME;

	}

	public String getDataStoreName() {

		return NetCDFProvider.NAME;

	}

	public String getDescription() {

		return NetCDFProvider.DESCRIPTION;

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return delegatedDynObject;

	}

}

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