Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

*

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

* of the Valencian Government (CIT)

*

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

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

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

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

*

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

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

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

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

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

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

* MA  02110-1301, USA.

*

*/

/*

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

        }

}