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.tools.algorithm.layerdatatype;

import java.util.HashMap;

import javax.swing.SwingUtilities;

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

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

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

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.RasterQuery;

import org.gvsig.i18n.Messages;

import org.gvsig.raster.tools.algorithm.base.RasterBaseAlgorithmLibrary;

import org.gvsig.raster.tools.algorithm.base.process.RasterProcess;

/**

 * Process to change a <code>RasterDataStore</code> of data type

 *

 * 10/12/2007

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public class LayerDatatypeProcess extends RasterProcess {

        public static String      RASTER_STORE1     = "RasterStore1";

        public static String      PATH              = "Path";

        public static String      FILENAME          = "FileName";

        public static String      DATATYPE          = "Datatype";

        public static String      ADJUST_DEC2INT    = "AdjustDec2Int";

        public static String      ADJUST_BIG2SMALL  = "AdjustBig2Small";

        public static String      TIME              = "Time";

        public static String[]    DEC2INT_OPTIONS   = new String[]{"Trunk", "Round", 

        "Ceil", "Floor"};

        public static String[]    BIG2SMALL_OPTIONS = new String[]{"Trunk", "Maxvalue", 

        "NoData"};

        public static String      RESULT_DSTORE           = "RESULT_DSTORE";

        private RasterDataStore   store             = null;

        private String            filename          = null;

        private int               datatype          = 0;

        private int               dec2int           = 0;

        private int               big2smal          = 0;

        private long              milis             = 0;

        private int               percent           = 0;

        private NoData            byteNoData        = null;

        private NoData            shortNoData       = null;

        private NoData            intNoData         = null;

        private NoData            floatNoData       = null;

        private NoData            doubleNoData      = null;

        public static void registerParameters() {

                RASTER_STORE1 = RasterBaseAlgorithmLibrary.registerInputParameter(RASTER_STORE1, RasterDataStore.class);

                PATH = RasterBaseAlgorithmLibrary.registerInputParameter(PATH, String.class);

                DATATYPE = RasterBaseAlgorithmLibrary.registerInputParameter(DATATYPE, Integer.class);

                ADJUST_DEC2INT = RasterBaseAlgorithmLibrary.registerInputParameter(ADJUST_DEC2INT, Integer.class);

                ADJUST_BIG2SMALL = RasterBaseAlgorithmLibrary.registerInputParameter(ADJUST_BIG2SMALL, Integer.class);

                RESULT_DSTORE = RasterBaseAlgorithmLibrary.registerOutputParameter(RESULT_DSTORE, RasterDataStore.class);

                FILENAME = RasterBaseAlgorithmLibrary.registerOutputParameter(FILENAME, String.class);

                TIME = RasterBaseAlgorithmLibrary.registerOutputParameter(TIME, Long.class);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.rastertools.RasterProcess#init()

         */

        public void init() {

                store = getParam(RASTER_STORE1) != null ? (RasterDataStore)getParam(RASTER_STORE1) : null;

                filename = getStringParam(PATH);

                datatype = (Integer)getParam(DATATYPE);

                dec2int = (Integer)getParam(ADJUST_DEC2INT);

                big2smal = (Integer)getParam(ADJUST_BIG2SMALL);

                byteNoData = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

                                store.getBandCount(), Buffer.TYPE_BYTE);

                shortNoData = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

                                store.getBandCount(), Buffer.TYPE_SHORT);

                intNoData = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

                                store.getBandCount(), Buffer.TYPE_INT);

                floatNoData = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

                                store.getBandCount(), Buffer.TYPE_FLOAT);

                doubleNoData = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

                                store.getBandCount(), Buffer.TYPE_DOUBLE);

        }

        public void process() throws ProcessInterruptedException {

                long t1 = new java.util.Date().getTime();

                insertLineLog(Messages.getText("layer_datatype"));

                int result = 1;

                try {

                        if (store == null)

                                throw new LayerDatatypeException("intput_not_valid");

                        int inDataType = store.getDataType()[0];

                        Buffer buf = RasterLocator.getManager().createBuffer(

                                        datatype, 

                                        (int)store.getWidth(), 

                                        (int)store.getHeight(), 

                                        store.getBandCount(), 

                                        true);

                        RasterQuery query = RasterLocator.getManager().createQuery();

                        query.setAllDrawableBands();

                        query.setAreaOfInterest();

                        Buffer sourceBuffer;

                        try {

                                sourceBuffer = store.query(query);

                        } catch (RasterDriverException e) {

                                throw new LayerDatatypeException("");

                        } catch (InvalidSetViewException e) {

                                throw new LayerDatatypeException("");

                        }

                        double v = 0;

                        for (int row = 0; row < buf.getHeight(); row++) {

                                for (int col = 0; col < buf.getWidth(); col++) {

                                        for (int iBand = 0; iBand < buf.getBandCount(); iBand++) {

                                                switch (inDataType) {

                                                case Buffer.TYPE_BYTE:

                                                        break;

                                                case Buffer.TYPE_SHORT:

                                                        break;

                                                case Buffer.TYPE_INT:

                                                        break;

                                                case Buffer.TYPE_FLOAT:

                                                        v = getDecimalValue(sourceBuffer.getElemFloat(row, col, iBand), inDataType);

                                                        break;

                                                case Buffer.TYPE_DOUBLE:

                                                        v = getDecimalValue(sourceBuffer.getElemDouble(row, col, iBand), inDataType);

                                                        break;

                                                }

                                        }

                                }

                        }

                        if(result != 0) {

                                if (incrementableTask != null) {

                                        incrementableTask.processFinalize();

                                        setProgressActive(false);

                                }

                                messageBoxError("transformation_not_possible", this);

                                return;

                        }

                        long t2 = new java.util.Date().getTime();

                        milis = t2 - t1;

                        SwingUtilities.invokeLater(new Runnable() {

                                public void run() {

                                        if (externalActions != null) {

                                                HashMap<String, Object> map = new HashMap<String, Object>();

                                                map.put(FILENAME, filename);

                                                map.put(TIME, new Long(milis));

                                                externalActions.end(map);

                                        }

                                }

                        });

                } catch (LayerDatatypeException e) {

                        if (incrementableTask != null)

                                incrementableTask.processFinalize();

                        messageBoxError("error_changing_the_datatype", this, e);

                }

        }

        public double getDecimalValue(double value, int inDataType) {

                if(inDataType == Buffer.TYPE_FLOAT || inDataType == Buffer.TYPE_DOUBLE) {

                        switch (dec2int) {

                        case 0:return (double)((long)value);

                        case 1:return Math.round(value);

                        case 2:return Math.ceil(value);

                        case 3:return Math.floor(value);

                        }

                } 

                return value;

        }

        private void writePixelFromByte(int row, int col, int band, byte value, Buffer dst) {

                switch (dst.getDataType()) {

                case Buffer.TYPE_BYTE: dst.setElem(row, col, band, value);break;

                case Buffer.TYPE_SHORT: dst.setElem(row, col, band, (short)value);break;

                case Buffer.TYPE_INT: dst.setElem(row, col, band, (int)value);break;

                case Buffer.TYPE_FLOAT: dst.setElem(row, col, band, (float)value);break;

                case Buffer.TYPE_DOUBLE: dst.setElem(row, col, band, (double)value);break;

                }

        }

        private void writePixelFromShort(int row, int col, int band, short value, Buffer dst) {

                switch (dst.getDataType()) {

                case Buffer.TYPE_BYTE: 

                        if(value > Byte.MAX_VALUE) {

                                switch (big2smal) {

                                case 0:dst.setElem(row, col, band, (byte)value);break;

                                case 1:dst.setElem(row, col, band, Byte.MAX_VALUE);break;

                                case 2:dst.setElem(row, col, band, (Byte)byteNoData.getValue());break;

                                }

                        }

                        break;

                case Buffer.TYPE_SHORT: dst.setElem(row, col, band, value);break;

                case Buffer.TYPE_INT: dst.setElem(row, col, band, (int)value);break;

                case Buffer.TYPE_FLOAT: dst.setElem(row, col, band, (float)value);break;

                case Buffer.TYPE_DOUBLE: dst.setElem(row, col, band, (double)value);break;

                }

        }

        private void writePixelFromInt(int row, int col, int band, int value, Buffer dst) {

                switch (dst.getDataType()) {

                case Buffer.TYPE_BYTE: 

                        if(value > Byte.MAX_VALUE) {

                                switch (big2smal) {

                                case 0:dst.setElem(row, col, band, (byte)value);break;

                                case 1:dst.setElem(row, col, band, Byte.MAX_VALUE);break;

                                case 2:dst.setElem(row, col, band, (Byte)byteNoData.getValue());break;

                                }

                        }

                        break;

                case Buffer.TYPE_SHORT:

                        if(value > Short.MAX_VALUE) {

                                switch (big2smal) {

                                case 0:dst.setElem(row, col, band, (short)value);break;

                                case 1:dst.setElem(row, col, band, Short.MAX_VALUE);break;

                                case 2:dst.setElem(row, col, band, (Short)shortNoData.getValue());break;

                                }

                        }

                        break;

                case Buffer.TYPE_INT: dst.setElem(row, col, band, (int)value);break;

                case Buffer.TYPE_FLOAT: dst.setElem(row, col, band, (float)value);break;

                case Buffer.TYPE_DOUBLE: dst.setElem(row, col, band, (double)value);break;

                }

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.tools.app.basic.raster.process.RasterProcess#getResult()

         */

        public Object getResult() {

                HashMap<String, Object> map = new HashMap<String, Object>();

                map.put(FILENAME, filename);

                map.put(TIME, new Long(milis));

                return map;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.gui.beans.incrementabletask.IIncrementable#getPercent()

         */

        public int getPercent() {

                return percent;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.gui.beans.incrementabletask.IIncrementable#getTitle()

         */

        public String getTitle() {

                return Messages.getText("layer_datatype");

        }

}