Application: gvSIG desktop » gvSIG raster

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.

 *

 */

package org.gvsig.raster.netcdf.io;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.IOException;

import java.util.List;

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.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 org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

	 */

	public NetCDFProvider(String params) throws NotSupportedExtensionException, OpenException {

		super(params);

		if(params instanceof String) {

			NetCDFDataParameters p = new NetCDFDataParametersImpl();

			p.setURI((String)params);

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

	}

	public RasterProvider load() {

		return this;

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

		try {

			gridNetCDF.close();

		} catch (IOException e) {

			logger.error("Error closing file", e);

		}

	}

	public String translateFileName(String fileName) {

		return fileName;

	}

	/**

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

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

	 * ha de estar en coordenadas del fichero.

	 */

	public void setView(Extent e) {

		viewRequest = new ExtentImpl(e);

	}

	public Extent getView() {

		return viewRequest;

	}

	public double getWidth() {

		return selectedGridDataType.getXDimension().getLength();

	}

	public double getHeight() {

		return selectedGridDataType.getYDimension().getLength();

	}

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

		throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

		NetCDFDataParameters p = (NetCDFDataParameters)param;

		if(pos < 0)

			throw new InvalidSetViewException("Request out of grid");

		if((pos + blockHeight) > getHeight())

			blockHeight = Math.abs(((int)getHeight()) - pos);

		Buffer buf = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], (int)getWidth(), blockHeight, 1, true);

		try {

			int time = p.getFieldTime();

			int level = getLevelValue();

			Range rangeY = new Range(pos, pos + blockHeight - 1, 1);

			Range rangeX = new Range(0, (int)(getWidth() - 1), 1);

			GridDatatype dt = selectedGridDataType.makeSubset(null, null, null, null /*getTime(1), getLevel(1)*/, rangeY, rangeX);

			Array values = dt.readDataSlice(time, level, -1, -1);

			return arrayValuesToBuffer(values, buf, rangeX.length(), rangeY.length(), null);

		} catch (IOException e) {

			throw new RasterDriverException("Error reading a slice", e);

		} catch (InvalidRangeException e) {

			throw new RasterDriverException("Error reading a slice", e);

		}

	}

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

		NetCDFDataParameters p = (NetCDFDataParameters)param;

		if(x < 0 || y < 0 || x >= getWidth() || y >= getHeight())

			throw new InvalidSetViewException("Request out of grid");

		try {

			int strideX = 1;

			int strideY = 1;

			Range rangeY = new Range((int)(getHeight() - y), (int)(getHeight() - y), strideY);

			Range rangeX = new Range(x, x, strideX);

			selectSubdataset();

			int time = p.getFieldTime();

			int level = getLevelValue();

			GridDatatype dt = selectedGridDataType.makeSubset(null, null, null, null, rangeY, rangeX);

			Array values = dt.readDataSlice(time, level, -1, -1);

			Object data = null;

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

				data = new java.lang.Integer(values.getByte(0));

			}

			if(getDataType()[0] == Buffer.TYPE_SHORT) {

				data = new java.lang.Integer(values.getShort(0));

			}

			if(getDataType()[0] == Buffer.TYPE_INT) {

				data = new java.lang.Integer(values.getInt(0));

			}

			if(getDataType()[0] == Buffer.TYPE_FLOAT) {

				data = new java.lang.Float(values.getFloat(0));

			}

			if(getDataType()[0] == Buffer.TYPE_DOUBLE) {

				data = new java.lang.Double(values.getDouble(0));

			}

			return data;

		} catch (IOException e) {

			throw new RasterDriverException("Error reading a slice", e);

		} catch (InvalidRangeException e) {

			throw new RasterDriverException("Error reading a slice", e);

		}

	}

	@Override

	public void loadBuffer(SpiRasterQuery query)

			throws ProcessInterruptedException, RasterDriverException {

		NetCDFDataParameters p = (NetCDFDataParameters)param;

		setView(query.getAdjustedRequestBoundingBox());

		Point2D ul = new Point2D.Double(viewRequest.getULX(), viewRequest.getULY());

		Point2D lr = new Point2D.Double(viewRequest.getLRX(), viewRequest.getLRY());

		ul = worldToRaster(ul);

		lr = worldToRaster(lr);

		ul.setLocation(ul.getX() < 0 ? 0 : ul.getX(), ul.getY() < 0 ? 0 : ul.getY());

		lr.setLocation(lr.getX() < 0 ? 0 : lr.getX(), lr.getY() < 0 ? 0 : lr.getY());

		ul.setLocation(ul.getX() >= getWidth() ? getWidth() - 1 : ul.getX(), ul.getY() >= getHeight() ? getHeight() - 1 : ul.getY());

		lr.setLocation(lr.getX() >= getWidth() ? getWidth() - 1 : lr.getX(), lr.getY() >= getHeight() ? getHeight() - 1 : lr.getY());

		adjustPoints(ul, lr);

		//int width = Math.abs(((int)lr.getX()) - ((int)ul.getX()));

		//int height = Math.abs(((int)lr.getY()) - ((int)ul.getY()));

		try {

			int strideX = 1;

			int strideY = 1;

			Range rangeY = new Range((int)(getHeight() - lr.getY()), (int)(getHeight() - ul.getY() - 1), strideY <= 0 ? 1 : strideY);

			Range rangeX = new Range((int)ul.getX(), (int)(lr.getX() - 1), strideX <= 0 ? 1 : strideX);

			selectSubdataset();

			int time = p.getFieldTime();

			int level = getLevelValue();

			GridDatatype dt = selectedGridDataType.makeSubset(null, null, null, null /*getTime(strideX), getLevel(strideX)*/, rangeY, rangeX);

			Array values = dt.readDataSlice(time, level, -1, -1);

			Rectangle2D r = query.getBufferForProviders().getDataExtent();

			Buffer rasterBuf = arrayValuesToBuffer(

					values, 

					query.getBufferForProviders(), 

					rangeX.length(), 

					rangeY.length(), 

					query.getBandList());

			rasterBuf.setDataExtent(r);

			query.setBufferResult(rasterBuf);

		} catch (IOException e) {

			throw new RasterDriverException("Error reading a slice", e);

		} catch (InvalidRangeException e) {

			throw new RasterDriverException("Error reading a slice", e);

		}

	}

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

		throws ProcessInterruptedException, RasterDriverException {

		NetCDFDataParameters p = (NetCDFDataParameters)param;

		setView(extent);

		Point2D ul = new Point2D.Double(viewRequest.getULX(), viewRequest.getULY());

		Point2D lr = new Point2D.Double(viewRequest.getLRX(), viewRequest.getLRY());

		ul = worldToRaster(ul);

		lr = worldToRaster(lr);

		ul.setLocation(ul.getX() < 0 ? 0 : ul.getX(), ul.getY() < 0 ? 0 : ul.getY());

		lr.setLocation(lr.getX() < 0 ? 0 : lr.getX(), lr.getY() < 0 ? 0 : lr.getY());

		ul.setLocation(ul.getX() > getWidth() ? getWidth() : ul.getX(), ul.getY() > getHeight() ? getHeight() : ul.getY());

		lr.setLocation(lr.getX() > getWidth() ? getWidth() : lr.getX(), lr.getY() > getHeight() ? getHeight() : lr.getY());

		adjustPoints(ul, lr);

		try {

			int strideX = 1;

			int strideY = 1;

			Range rangeY = new Range((int)(getHeight() - lr.getY()), (int)(getHeight() - ul.getY() - 1), strideY);

			Range rangeX = new Range((int)ul.getX(), (int)(lr.getX() - 1), strideX);

			selectSubdataset();

			int time = p.getFieldTime();

			int level = getLevelValue();

			GridDatatype dt = selectedGridDataType.makeSubset(null, null, null, null , rangeY, rangeX);

			Array values = dt.readDataSlice(time, level, -1, -1);

			rasterBuf = arrayValuesToBuffer(values, rasterBuf, rangeX.length(), rangeY.length(), bandList);

		} catch (IOException e) {

			throw new RasterDriverException("Error reading a slice", e);

		} catch (InvalidRangeException e) {

			throw new RasterDriverException("Error reading a slice", e);

		}

		return rasterBuf;

	}*/

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

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

		NetCDFDataParameters p = (NetCDFDataParameters)param;

		setView(extent);

		Point2D ul = new Point2D.Double(viewRequest.getULX(), viewRequest.getULY());

		Point2D lr = new Point2D.Double(viewRequest.getLRX(), viewRequest.getLRY());

		ul = worldToRaster(ul);

		lr = worldToRaster(lr);

		ul.setLocation(ul.getX() < 0 ? 0 : ul.getX(), ul.getY() < 0 ? 0 : ul.getY());

		lr.setLocation(lr.getX() < 0 ? 0 : lr.getX(), lr.getY() < 0 ? 0 : lr.getY());

		ul.setLocation(ul.getX() >= getWidth() ? getWidth() - 1 : ul.getX(), ul.getY() >= getHeight() ? getHeight() - 1 : ul.getY());

		lr.setLocation(lr.getX() >= getWidth() ? getWidth() - 1 : lr.getX(), lr.getY() >= getHeight() ? getHeight() - 1 : lr.getY());

		adjustPoints(ul, lr);

		int width = Math.abs(((int)lr.getX()) - ((int)ul.getX()));

		int height = Math.abs(((int)lr.getY()) - ((int)ul.getY()));

		try {

			int strideX = width / rasterBuf.getWidth();

			int strideY = height / rasterBuf.getHeight();

			Range rangeY = new Range((int)(getHeight() - lr.getY()), (int)(getHeight() - ul.getY() - 1), strideY <= 0 ? 1 : strideY);

			Range rangeX = new Range((int)ul.getX(), (int)(lr.getX() - 1), strideX <= 0 ? 1 : strideX);

			selectSubdataset();

			int time = p.getFieldTime();

			int level = getLevelValue();

			GridDatatype dt = selectedGridDataType.makeSubset(null, null, null, null , rangeY, rangeX);

			Array values = dt.readDataSlice(time, level, -1, -1);

			rasterBuf = arrayValuesToBuffer(values, rasterBuf, rangeX.length(), rangeY.length(), bandList);

		} catch (IOException e) {

			throw new RasterDriverException("Error reading a slice", e);

		} catch (InvalidRangeException e) {

			throw new RasterDriverException("Error reading a slice", e);

		}

		return rasterBuf;

	}*/

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

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

		try {

			NetCDFDataParameters p = (NetCDFDataParameters)param;

			int strideX = 1;

			int strideY = 1;

			Range rangeY = new Range((int)(h - y), (int)(h - y - 1), strideY);

			Range rangeX = new Range((int)x, (int)(x + w - 1), strideX);

			selectSubdataset();

			int time = p.getFieldTime();

			int level = getLevelValue();

			GridDatatype dt = selectedGridDataType.makeSubset(null, null, null, null, rangeY, rangeX);

			Array values = dt.readDataSlice(time, level, -1, -1);

			rasterBuf = arrayValuesToBuffer(values, rasterBuf, rangeX.length(), rangeY.length(), bandList);

		} catch (IOException e) {

			throw new RasterDriverException("Error reading a slice", e);

		} catch (InvalidRangeException e) {

			throw new RasterDriverException("Error reading a slice", e);

		}

		return rasterBuf;

	}*/

	/**

	 * Gets the Range of the selected time or null if there is not a selected time

	 * @param strideX

	 * @return

	 * @throws InvalidRangeException

	 */

	@SuppressWarnings("unused")

	private Range getTime(int strideX) throws InvalidRangeException {

		NetCDFDataParameters p = (NetCDFDataParameters)param;

		int time = p.getFieldTime();

		return new Range(time, time, strideX);

	}

	/*private int getTimeValue() {

		int time = 0;

		if(param.hasDynValue(NetCDFDataParameters.FIELD_TIME))

			time = ((Integer)param.getDynValue(NetCDFDataParameters.FIELD_TIME)).intValue();

		return time;

	}*/

	/**

	 * Gets the Range of the selected level or null if there is not a selected level

	 * @param strideX

	 * @return

	 * @throws InvalidRangeException

	 */

	@SuppressWarnings("unused")

	private Range getLevel(int strideX) throws InvalidRangeException {

		int level = getLevelValue();

		return new Range(level, level, strideX);

	}

	private int getLevelValue() {

		int level = 0;

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

			level = ((Integer)param.getDynValue(NetCDFDataParameters.FIELD_LEVEL)).intValue();

		return level;

	}

	/**

	 * Selects the GridDataType using the selected variable in the parameters

	 */

	public void selectSubdataset() {

		if(param.hasDynValue(NetCDFDataParameters.FIELD_VARIABLE)) {

			NetCDFDataParameters p = (NetCDFDataParameters)param;

			String variable = (String)param.getDynValue(NetCDFDataParameters.FIELD_VARIABLE);

			if(variable != null) {

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

					if(gridList.get(j).getName().compareTo(variable) == 0) {

						selectedGridDataType = gridList.get(j);

						reloadMetadataFromGrid();

						super.selectSubdataset(getId(j, getLevelValue(), p.getFieldTime()));

					}

				}

			}

		}

	}

	/**

	 * Gets the identifier of a subdataset

	 * @param grid

	 * @param level

	 * @param time

	 * @return

	 */

	private String getId(int grid, int level, int time) {

		return grid + "-" + level + "-" +  time;

	}

	/**

	 * Loads a Buffer object from an netCDF Array. 

	 * @param values

	 * @param rasterBuf

	 * @param w

	 * @param h

	 * @return

	 */

	private Buffer arrayValuesToBuffer(Array values, Buffer rasterBuf, int w, int h, BandList bandList) {

		Buffer buf = null;

		boolean resampling = false;

		if((rasterBuf.getWidth() * rasterBuf.getHeight()) != values.getSize()) {

			buf = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], w, h, rasterBuf.getBandCount(), true);

			resampling = true;

		} else

			buf = rasterBuf;

		int[] drawableBands = bandList != null ? bandList.getBufferBandToDraw(getURIOfFirstProvider(), 0) : new int[1];

		if(drawableBands == null || (drawableBands.length == 1 && drawableBands[0] == -1))

			return rasterBuf;

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

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

				int[] rc = getColAndRow(i, buf);

				for (int iBands = 0; iBands < drawableBands.length; iBands++) 

					buf.setElem(rc[0], rc[1], drawableBands[iBands], values.getByte(i));

			}

		}

		if(getDataType()[0] == Buffer.TYPE_SHORT) {

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

				int[] rc = getColAndRow(i, buf);

				for (int iBands = 0; iBands < drawableBands.length; iBands++) 

					buf.setElem(rc[0], rc[1], drawableBands[iBands], values.getShort(i));

			}

		}

		if(getDataType()[0] == Buffer.TYPE_INT) {

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

				int[] rc = getColAndRow(i, buf);

				for (int iBands = 0; iBands < drawableBands.length; iBands++) 

					buf.setElem(rc[0], rc[1], drawableBands[iBands], values.getInt(i));

			}

		}

		if(getDataType()[0] == Buffer.TYPE_FLOAT) {

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

				int[] rc = getColAndRow(i, buf);

				for (int iBands = 0; iBands < drawableBands.length; iBands++) 

					buf.setElem(rc[0], rc[1], drawableBands[iBands], values.getFloat(i));

			}

		}

		if(getDataType()[0] == Buffer.TYPE_DOUBLE) {

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

				int[] rc = getColAndRow(i, buf);

				for (int iBands = 0; iBands < drawableBands.length; iBands++) 

					buf.setElem(rc[0], rc[1], drawableBands[iBands], values.getDouble(i));

			}

		}

		if(resampling) {

			try {

				Buffer result = null;

				result = buf.getAdjustedWindow(rasterBuf.getWidth(), rasterBuf.getHeight(), Buffer.INTERPOLATION_NearestNeighbour);

				if(result != buf)

					buf.dispose();

				return result;

			} catch (ProcessInterruptedException e) {

				return buf;

			}

		}

		return buf;

	}

	/**

	 * Calculates the row and column number for the position i in the

	 * array of data

	 * @param i

	 * @param buf

	 * @return

	 */

	private int[] getColAndRow(int i, Buffer buf) {

		int auxRow = (int)(i / buf.getWidth());

		return new int[]{ 

				(int)buf.getHeight() - auxRow - 1,

				i - (auxRow * buf.getWidth())

				};

	}

	private void adjustPoints(Point2D ul, Point2D lr) {

		double a = (ul.getX() - (int)ul.getX());

		double b = (ul.getY() - (int)ul.getY());

		ul.setLocation(	(a > 0.95 || a < 0.05) ? Math.round(ul.getX()) : ul.getX(), 

						(b > 0.95 || b < 0.05) ? Math.round(ul.getY()) : ul.getY());

		lr.setLocation(	(a > 0.95 || a < 0.05) ? Math.round(lr.getX()) : lr.getX(), 

						(b > 0.95 || b < 0.05) ? Math.round(lr.getY()) : lr.getY());

	}

	public int getBlockSize(){

		return 0;

	}

	public ColorInterpretation getColorInterpretation() {

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

			setColorInterpretation(new DataStoreColorInterpretation(new String[]{ColorInterpretation.GRAY_BAND}));

		}

		return super.getColorInterpretation();

	}

	public DataStoreTransparency getTransparency() {

		if(fileTransparency == null)

			fileTransparency = new DataStoreTransparency(getColorInterpretation());

		return fileTransparency;

	}

	/**

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

	 * el valor de esta variable cada vez que dibuja.

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

	 */

	public boolean isSupersampling() {

		return false;

	}

	public void setAffineTransform(AffineTransform t){

		super.setAffineTransform(t);

	}

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

		if(band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

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

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

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

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

	public boolean isOverviewsSupported() {

		return true;

	}

	public boolean isReproyectable() {

		return true;

	}

	public String getName() {

		return NAME;

	}

	public void setStatus(RasterProvider provider) {

		if(provider instanceof NetCDFProvider) {

			//Not implemented yet

		}

	}

	public boolean isTimeSupported() {

		return true;

	}

	public TileServer getTileServer() {

		if(tileServer == null) {

			DefaultRasterStore store = new DefaultRasterStore();

			store.setProvider(this);

			tileServer = new FileTileServer(store);

		}

		return tileServer;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

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

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

/*

* 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):