data/xulugridfile/XuluGridFileConverter.java

/*
 *    Geotools2 - OpenSource mapping toolkit
 *    http://geotools.org
 *    (C) 2002, Geotools Project Managment Committee (PMC)
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation;
 *    version 2.1 of the License.
 *
 *    This library 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
 *    Lesser General Public License for more details.
 *
 */
package appl.parallel.data.xulugridfile;
import gtmig.org.geotools.gce.arcgrid.ArcGridRaster;

import java.awt.image.DataBuffer;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.io.StreamTokenizer;

import appl.util.RasterMetaData;


/**
 * This class converts a ArcGridInfo_ASCII file to a {@link XuluGridFile}. It directly writes from
 * the the ArcGridInfo to the given file. It does not use the memory!
 *
 * It is a modified geotools import class. Buffering was added.
 *
 * @author Dominik Appl <br>
 * For reading this class is based partly on the Geotools class {@link ArcGridRaster}. This was
 * done to make sure that EVERY ArcInfoASCII can be read. The used {@link ArcGridRaster} was created by <br>
 * @author <a href="mailto:[email protected]">Christiaan ten Klooster</a>
 * @author <a href="mailto:[email protected]">Andrea Aime</a>
 * @author <a href="mailto:[email protected]">Simone Giannecchini
 *         (simboss)</a>
 * @see XuluGridFile
 * @see http://svn.geotools.org/geotools/tags/2.2.0/plugin/arcgrid/src/org/geotools/gce/arcgrid/ArcGridRaster.java
 */

public class XuluGridFileConverter extends ArcGridRaster {

    protected final File inputArcInfoGrid;
        protected final File outputXuluGridFile;

        /**
         * @throws FileNotFoundException
         */
        public XuluGridFileConverter(File inputArcInfoGrid, File outputXuluGridFile) throws FileNotFoundException {
                super(new BufferedReader(new InputStreamReader(new FileInputStream(inputArcInfoGrid))), false);
                this.inputArcInfoGrid = inputArcInfoGrid;
                this.outputXuluGridFile = outputXuluGridFile;
        }


   /**
     * partly copied from Geotools. www.geotools.org.
     *
     * @param type the type of the values. Use the
     * {@link DataBuffer} constants to identify the type
     *
     * @return the new XuluGridFile
     *
     * @throws IOException
     * @throws XuluGridFileException
     */
    public XuluGridFile convertArcInfoToXuluGridFile(int type) throws IOException, XuluGridFileException {


        // open reader and make tokenizer
        Reader reader = openReader();
        StreamTokenizer st = new StreamTokenizer(reader);

        // parse header
        parseHeader(st);

        //create metadata and outputFile
        RasterMetaData meta = new RasterMetaData(type,getNCols(),getNRows(),0,0,getXlCorner(),getYlCorner(),getCellSize(),null);
        RandomAccessFile outputFile = new RandomAccessFile(outputXuluGridFile,"rw");

        // reconfigure tokenizer
        st.resetSyntax();
        st.parseNumbers();
        st.whitespaceChars(' ', ' ');
        st.whitespaceChars(' ', '\t');
        st.whitespaceChars('\n', '\n');
        st.whitespaceChars('\r', '\r'); //linefeed (on windows only?)
        st.whitespaceChars('\f', '\f'); //form feed (on printers????)
        st.eolIsSignificant(false);
        st.ordinaryChars('E', 'E');


        // Read values from grid and put into raster.
        // Values must be numbers, which may be simple <num>, or expressed
        // in scientific notation <num>E<exp>.
        // The following loop can read both, even if mixed.
        // The loop expects a token to be read already
        st.nextToken();


        for (int y = 0; y < getNRows(); y++) {
                ByteArrayOutputStream baos;
                if(type == DataBuffer.TYPE_DOUBLE)
                        baos = new ByteArrayOutputStream(getNCols()*8);
                else
                        baos = new ByteArrayOutputStream(getNCols()*4);

                for (int x = 0; x < getNCols(); x++) {
                // this call always reads the next token
                double d = readCell(st, x, y);

                // mask no data values with NaN
                if (d == getNoData()) {
                    d = Double.NaN;
                } else {
                    minValue = Math.min(minValue, d);
                    maxValue = Math.max(maxValue, d);
                }
                switch(type){
                case DataBuffer.TYPE_FLOAT:
                        BufferedHelper.writeInt(Float.floatToIntBits((float)d),baos);
                break;
                case DataBuffer.TYPE_DOUBLE:
                        BufferedHelper.writeLong(Double.doubleToLongBits(d),baos);
                case DataBuffer.TYPE_INT:
                        BufferedHelper.writeInt((int)d,baos);
                break;
                default:
                        throw new UnsupportedOperationException("Unsupported datatype");
            }
                outputFile.write(baos.toByteArray());
                baos.reset();
        }
        }
        reader.close();
        try {
                        XuluGridFile.writeWorldFileForMetaData(outputXuluGridFile, meta);
                } catch (XuluGridFileException e) {
                        throw new IOException ("Could not write WorldFile");
                }
        return new XuluGridFile(outputXuluGridFile,"rw");
    }

    /**
     *copied unmodified form superclass (had to be copied, because the geotools method was private)
     */
    private double readCell(StreamTokenizer st, int x, int y)
        throws IOException {
        double d = 0;

        // read a token, expected: a number
        switch (st.ttype) {
        case StreamTokenizer.TT_NUMBER:
            d = (float) st.nval;

            break;

        case StreamTokenizer.TT_EOF:
            throw new IOException("Unexpected EOF at " + x + "," + y);

        default:
            throw new IOException("Unknown token " + st.ttype);
        }

        // read another. May be an exponent of this number.
        // If its not an exponent, its the next number. Fall through
        // and token is prefetched for next loop...
        switch (st.nextToken()) {
        case 'e':
        case 'E':

            // now read the exponent
            st.nextToken();

            if (st.ttype != StreamTokenizer.TT_NUMBER) {
                throw new IOException("Expected exponent at " + x + "," + y);
            }

            // calculate
            d = d * Math.pow(10.0, st.nval);

            // prefetch for next loop
            st.nextToken();

            break;

        case StreamTokenizer.TT_NUMBER:
        case StreamTokenizer.TT_EOF:
            break;

        default:
            throw new IOException("Expected Number or EOF");
        }

        return d;
    }

   /** You can use this method to manually convert datatypes
 * @param args
 */
public static void main(String[] args) {
           int type=DataBuffer.TYPE_FLOAT;
           if((args.length!=2 && args.length!=3)){
                   parameterMessage();
           return;
           }
           if(!args[1].endsWith(".xgrid")){
                   parameterMessage();
                   return;
           }
           if(args.length==3){
                        if(args[2].equals("INT"))
                                type=DataBuffer.TYPE_INT;
                        if(args[2].equals("DOUBLE"))
                                type = DataBuffer.TYPE_DOUBLE;
                }
                XuluGridFileConverter converter;
                try {
                        converter = new XuluGridFileConverter(new File(args[0]),new File(args[1]));
                        converter.convertArcInfoToXuluGridFile(type);
                } catch (FileNotFoundException e) {
                        System.out.println("Could not find file " + args[0]);
                } catch (IOException e) {
                        System.out.println("IOException while converting: " + e.getMessage());
                } catch (XuluGridFileException e) {
                        System.out.println("XuluGridFileException while converting: " + e.getMessage());
                }


   }
   public static void parameterMessage(){
   System.out.println("Syntax: XuluGridFileConverter Source Target [type], where \n" +
                "Source = a raster in the ArcInfo_ASCII format \n" +
                "Target = the new XuluGridFile with the extension .xgrid \n" +
                "[type] = (optional) the type of the XuluGridFile. Possible Values: INT,FLOAT,DOUBLE\n" +
                " default type is FLOAT");
   }
}

1	mojays	2	/*
2			* Geotools2 - OpenSource mapping toolkit
3			* http://geotools.org
4			* (C) 2002, Geotools Project Managment Committee (PMC)
5			*
6			* This library is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation;
9			* version 2.1 of the License.
10			*
11			* This library is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			*/
17			package appl.parallel.data.xulugridfile;
18	mojays	52	import gtmig.org.geotools.gce.arcgrid.ArcGridRaster;
19	mojays	2
20			import java.awt.image.DataBuffer;
21			import java.io.BufferedReader;
22			import java.io.ByteArrayOutputStream;
23			import java.io.File;
24			import java.io.FileInputStream;
25			import java.io.FileNotFoundException;
26			import java.io.IOException;
27			import java.io.InputStreamReader;
28			import java.io.RandomAccessFile;
29			import java.io.Reader;
30			import java.io.StreamTokenizer;
31
32	alfonx	60	import appl.util.RasterMetaData;
33	mojays	2
34	alfonx	60
35	mojays	2	/**
36			* This class converts a ArcGridInfo_ASCII file to a {@link XuluGridFile}. It directly writes from
37			* the the ArcGridInfo to the given file. It does not use the memory!
38			*
39			* It is a modified geotools import class. Buffering was added.
40			*
41			* @author Dominik Appl <br>
42			* For reading this class is based partly on the Geotools class {@link ArcGridRaster}. This was
43			* done to make sure that EVERY ArcInfoASCII can be read. The used {@link ArcGridRaster} was created by <br>
44			* @author <a href="mailto:[email protected]">Christiaan ten Klooster</a>
45			* @author <a href="mailto:[email protected]">Andrea Aime</a>
46			* @author <a href="mailto:[email protected]">Simone Giannecchini
47			* (simboss)</a>
48			* @see XuluGridFile
49			* @see http://svn.geotools.org/geotools/tags/2.2.0/plugin/arcgrid/src/org/geotools/gce/arcgrid/ArcGridRaster.java
50			*/
51
52			public class XuluGridFileConverter extends ArcGridRaster {
53
54			protected final File inputArcInfoGrid;
55			protected final File outputXuluGridFile;
56
57			/**
58			* @throws FileNotFoundException
59			*/
60			public XuluGridFileConverter(File inputArcInfoGrid, File outputXuluGridFile) throws FileNotFoundException {
61			super(new BufferedReader(new InputStreamReader(new FileInputStream(inputArcInfoGrid))), false);
62			this.inputArcInfoGrid = inputArcInfoGrid;
63			this.outputXuluGridFile = outputXuluGridFile;
64			}
65
66
67			/**
68			* partly copied from Geotools. www.geotools.org.
69			*
70			* @param type the type of the values. Use the
71			* {@link DataBuffer} constants to identify the type
72			*
73			* @return the new XuluGridFile
74			*
75			* @throws IOException
76			* @throws XuluGridFileException
77			*/
78			public XuluGridFile convertArcInfoToXuluGridFile(int type) throws IOException, XuluGridFileException {
79
80
81
82			// open reader and make tokenizer
83			Reader reader = openReader();
84			StreamTokenizer st = new StreamTokenizer(reader);
85
86			// parse header
87			parseHeader(st);
88
89			//create metadata and outputFile
90			RasterMetaData meta = new RasterMetaData(type,getNCols(),getNRows(),0,0,getXlCorner(),getYlCorner(),getCellSize(),null);
91			RandomAccessFile outputFile = new RandomAccessFile(outputXuluGridFile,"rw");
92
93			// reconfigure tokenizer
94			st.resetSyntax();
95			st.parseNumbers();
96			st.whitespaceChars(' ', ' ');
97			st.whitespaceChars(' ', '\t');
98			st.whitespaceChars('\n', '\n');
99			st.whitespaceChars('\r', '\r'); //linefeed (on windows only?)
100			st.whitespaceChars('\f', '\f'); //form feed (on printers????)
101			st.eolIsSignificant(false);
102			st.ordinaryChars('E', 'E');
103
104
105
106			// Read values from grid and put into raster.
107			// Values must be numbers, which may be simple <num>, or expressed
108			// in scientific notation <num>E<exp>.
109			// The following loop can read both, even if mixed.
110			// The loop expects a token to be read already
111			st.nextToken();
112
113
114			for (int y = 0; y < getNRows(); y++) {
115			ByteArrayOutputStream baos;
116			if(type == DataBuffer.TYPE_DOUBLE)
117			baos = new ByteArrayOutputStream(getNCols()*8);
118			else
119			baos = new ByteArrayOutputStream(getNCols()*4);
120
121			for (int x = 0; x < getNCols(); x++) {
122			// this call always reads the next token
123			double d = readCell(st, x, y);
124
125			// mask no data values with NaN
126			if (d == getNoData()) {
127			d = Double.NaN;
128			} else {
129			minValue = Math.min(minValue, d);
130			maxValue = Math.max(maxValue, d);
131			}
132			switch(type){
133			case DataBuffer.TYPE_FLOAT:
134			BufferedHelper.writeInt(Float.floatToIntBits((float)d),baos);
135			break;
136			case DataBuffer.TYPE_DOUBLE:
137			BufferedHelper.writeLong(Double.doubleToLongBits(d),baos);
138			case DataBuffer.TYPE_INT:
139			BufferedHelper.writeInt((int)d,baos);
140			break;
141			default:
142			throw new UnsupportedOperationException("Unsupported datatype");
143			}
144			outputFile.write(baos.toByteArray());
145			baos.reset();
146			}
147			}
148			reader.close();
149			try {
150			XuluGridFile.writeWorldFileForMetaData(outputXuluGridFile, meta);
151			} catch (XuluGridFileException e) {
152			throw new IOException ("Could not write WorldFile");
153			}
154			return new XuluGridFile(outputXuluGridFile,"rw");
155			}
156
157			/**
158			*copied unmodified form superclass (had to be copied, because the geotools method was private)
159			*/
160			private double readCell(StreamTokenizer st, int x, int y)
161			throws IOException {
162			double d = 0;
163
164			// read a token, expected: a number
165			switch (st.ttype) {
166			case StreamTokenizer.TT_NUMBER:
167			d = (float) st.nval;
168
169			break;
170
171			case StreamTokenizer.TT_EOF:
172			throw new IOException("Unexpected EOF at " + x + "," + y);
173
174			default:
175			throw new IOException("Unknown token " + st.ttype);
176			}
177
178			// read another. May be an exponent of this number.
179			// If its not an exponent, its the next number. Fall through
180			// and token is prefetched for next loop...
181			switch (st.nextToken()) {
182			case 'e':
183			case 'E':
184
185			// now read the exponent
186			st.nextToken();
187
188			if (st.ttype != StreamTokenizer.TT_NUMBER) {
189			throw new IOException("Expected exponent at " + x + "," + y);
190			}
191
192			// calculate
193			d = d * Math.pow(10.0, st.nval);
194
195			// prefetch for next loop
196			st.nextToken();
197
198			break;
199
200			case StreamTokenizer.TT_NUMBER:
201			case StreamTokenizer.TT_EOF:
202			break;
203
204			default:
205			throw new IOException("Expected Number or EOF");
206			}
207
208			return d;
209			}
210
211			/** You can use this method to manually convert datatypes
212			* @param args
213			*/
214			public static void main(String[] args) {
215			int type=DataBuffer.TYPE_FLOAT;
216			if((args.length!=2 && args.length!=3)){
217			parameterMessage();
218			return;
219			}
220			if(!args[1].endsWith(".xgrid")){
221			parameterMessage();
222			return;
223			}
224			if(args.length==3){
225			if(args[2].equals("INT"))
226			type=DataBuffer.TYPE_INT;
227			if(args[2].equals("DOUBLE"))
228			type = DataBuffer.TYPE_DOUBLE;
229			}
230			XuluGridFileConverter converter;
231			try {
232			converter = new XuluGridFileConverter(new File(args[0]),new File(args[1]));
233			converter.convertArcInfoToXuluGridFile(type);
234			} catch (FileNotFoundException e) {
235			System.out.println("Could not find file " + args[0]);
236			} catch (IOException e) {
237			System.out.println("IOException while converting: " + e.getMessage());
238			} catch (XuluGridFileException e) {
239			System.out.println("XuluGridFileException while converting: " + e.getMessage());
240			}
241
242
243			}
244			public static void parameterMessage(){
245			System.out.println("Syntax: XuluGridFileConverter Source Target [type], where \n" +
246			"Source = a raster in the ArcInfo_ASCII format \n" +
247			"Target = the new XuluGridFile with the extension .xgrid \n" +
248			"[type] = (optional) the type of the XuluGridFile. Possible Values: INT,FLOAT,DOUBLE\n" +
249			" default type is FLOAT");
250			}
251			}
252