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.

 *

 */

package org.gvsig.raster.impl.datastruct;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

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

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

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

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

import org.gvsig.raster.impl.datastruct.serializer.NoDataRmfSerializer;

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

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

/**

 * This class represents the implementation of a nodata value.

 * 

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

 */

public class DefaultNoData implements NoData {

        private List<Number>             noDataByBand        = new ArrayList<Number>();

        private List<Number>             nativeNoDataByBand  = new ArrayList<Number>();

        private int                      bandCount           = 1;

        private String                   fileName            = null;

        private boolean                  noDataAsTransparent = true;

        private int                      dataType            = Buffer.TYPE_UNDEFINED;

        private final static Logger      log                 = Logger.getLogger(DefaultNoData.class.toString());

        /**

         * Constructor

         */

        public DefaultNoData() {

        }

        /**

         * Constructor.

         * @param fileName

         *               Name of file owner of this nodata value. This string is useful to 

         *        save and load throw the rmf.

         */

        public DefaultNoData(String fileName) {

                this.fileName = fileName;

        }

        /**

         * Constructor. Only for rasters with one band

         * 

         * @param noData

         *        value to assign to all bands

         * @param nativeNoData

         *        The native is the original value

         *        saved in the head of the file or its metadata.

         * @param fileName

         *        Name of file owner of this nodata value. This string is useful to 

         *        save and load throw the rmf.

         */

        public DefaultNoData(Number noData, Number nativeNoData, String fileName) {

                setValue(noData);

                setNativeValue(nativeNoData);

                this.fileName = fileName;

                setDataType(noData);

        }

        private void setDataType(Number number) {

                if(number instanceof Byte)

                        dataType = Buffer.TYPE_BYTE;

                if(number instanceof Short)

                        dataType = Buffer.TYPE_SHORT;

                if(number instanceof Integer)

                        dataType = Buffer.TYPE_INT;

                if(number instanceof Float)

                        dataType = Buffer.TYPE_FLOAT;

                if(number instanceof Double)

                        dataType = Buffer.TYPE_DOUBLE;

        }

        /**

         * Constructor

         * 

         * @param noData

         *        value to assign to all bands

         * @param nativeNoData

         *        The native is the original value

         *        saved in the head of the file or its metadata.

         * @param fileName

         *        Name of file owner of this nodata value. This string is useful to

         *        save the rmf file

         * @param bandCount

         *        Number of bands of the file

         */

        public DefaultNoData(Number noData, Number nativeNoData, String fileName, int bandCount) {

                setValue(noData);

                setNativeValue(nativeNoData);

                this.fileName = fileName;

                setDataType(noData);

                if(bandCount > 1)

                        this.bandCount = bandCount;

        }

        public Number getValue() {

                try {

                        return noDataByBand.get(0);

                } catch (ArrayIndexOutOfBoundsException e) {

                        return null;

                }

        }

        public boolean isDefined() {

                return (getValue() != null);

        }

        public void setValue(Number noData) {

                noDataByBand.clear();

                for (int i = 0; i < bandCount; i++) {

                        noDataByBand.add(noData);        

                }

                setDataType(noData);

        }

        public Number getNativeValue() {

                try {

                        return nativeNoDataByBand.get(0);

                } catch (ArrayIndexOutOfBoundsException e) {

                        return null;

                }

        }

        public void setNativeValue(Number nativeNoDataValue) {

                nativeNoDataByBand.clear();

                for (int i = 0; i < bandCount; i++) {

                        nativeNoDataByBand.add(nativeNoDataValue);        

                }

                setDataType(nativeNoDataValue);

        }

        public void delete() {

                noDataByBand.clear();

                for (int i = 0; i < bandCount; i++) {

                        noDataByBand.add(null);        

                }

        }

        public void restore() {

                if(nativeNoDataByBand != null && nativeNoDataByBand.size() == bandCount) {

                        noDataByBand.clear();

                        for (int i = 0; i < bandCount; i++) {

                                noDataByBand.add(nativeNoDataByBand.get(i));        

                        }

                }

        }

        public void save() {

                try {

                        String fileRMF = RasterLocator.getManager().getFileUtils().getNameWithoutExtension(fileName) + ".rmf";

                        RmfBlocksManager blocksManager = new RmfBlocksManager(fileRMF);

                        ClassSerializer serializerObject = new NoDataRmfSerializer(this);

                        if (!blocksManager.checkRmf())

                                throw new RmfSerializerException("Error al comprobar el fichero Rmf");

                        blocksManager.addClient(serializerObject);

                        try {

                                blocksManager.write(true);

                        } catch (IOException e) {

                                throw new RmfSerializerException("Error al escribir el fichero Rmf", e);

                        }

                        blocksManager.removeAllClients();

                } catch (RmfSerializerException e) {

                        log.log(Level.SEVERE, "error_salvando_rmf", e);

                }

        }

        public void load() {

                String fileRMF = RasterLocator.getManager().getFileUtils().getNameWithoutExtension(fileName) + ".rmf";

                RmfBlocksManager blocksManager = new RmfBlocksManager(fileRMF);

                ClassSerializer serializerObject = new NoDataRmfSerializer(this);

                if (!blocksManager.checkRmf()) {

                        log.info("Error al comprobar el fichero Rmf " + fileRMF);

                }

                blocksManager.addClient(serializerObject);

                try {

                        if(new File(fileRMF).exists())

                                blocksManager.read(null);

                } catch (Exception e) {

                        log.log(Level.WARNING, "Error al escribir el fichero Rmf", e);

                }

                blocksManager.removeAllClients();

        }

        public void setFileName(String fileName) {

                this.fileName = fileName;

        }

        public boolean isNoDataTransparent() {

                return noDataAsTransparent;

        }

        public void setNoDataTransparent(boolean noDataAsTransparent) {

                this.noDataAsTransparent = noDataAsTransparent;

        }

        public int getDataType() {

                return dataType;

        }

        public void setDataType(int datatype) {

                this.dataType = datatype;

        }

        @SuppressWarnings("unchecked")

        public boolean compare(NoData noData) {        

                String f = ((DefaultNoData)noData).fileName;

                if((f == null || fileName == null) && f != fileName)

                        return false;

                if( fileName != null &&  f != null &&

                        fileName.compareTo(f) != 0)

                        return false;

                if(bandCount != ((DefaultNoData)noData).bandCount)

                        return false;

                if(dataType != ((DefaultNoData)noData).dataType)

                        return false;

                for (int i = 0; i < noDataByBand.size(); i++) {

                        if(((Comparable<Number>)noDataByBand.get(i)).compareTo(noData.getValue()) != 0)

                                return false;

                }

                for (int i = 0; i < nativeNoDataByBand.size(); i++) {

                        if(((Comparable<Number>)nativeNoDataByBand.get(i)).compareTo(noData.getValue()) != 0)

                                return false;

                }

                return true;

        }

        public Object clone() {

                DefaultNoData copy = new DefaultNoData(getValue(), getNativeValue(), fileName, bandCount);

                copy.noDataAsTransparent = noDataAsTransparent;

                return copy;

        }

        //***********************************************

        //Only for file with more than one band

        public Number getValueByBand(int nBand) {

                try {

                        return noDataByBand.get(nBand);

                } catch (IndexOutOfBoundsException e) {

                        return null;

                }

        }

        public void setValueByBand(Number noDataValue, int nBand) {

                noDataByBand.add(nBand, noDataValue);

                setDataType(noDataValue);

        }

        public int getBandCount() {

                return bandCount;

        }

        public void setBandCount(int bandCount) {

                this.bandCount = bandCount;

        }

}