001 //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.3_testing/src/org/deegree/tools/raster/Text2Tiff.java $
002 /*----------------------------------------------------------------------------
003 This file is part of deegree, http://deegree.org/
004 Copyright (C) 2001-2009 by:
005 Department of Geography, University of Bonn
006 and
007 lat/lon GmbH
008
009 This library is free software; you can redistribute it and/or modify it under
010 the terms of the GNU Lesser General Public License as published by the Free
011 Software Foundation; either version 2.1 of the License, or (at your option)
012 any later version.
013 This library is distributed in the hope that it will be useful, but WITHOUT
014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016 details.
017 You should have received a copy of the GNU Lesser General Public License
018 along with this library; if not, write to the Free Software Foundation, Inc.,
019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020
021 Contact information:
022
023 lat/lon GmbH
024 Aennchenstr. 19, 53177 Bonn
025 Germany
026 http://lat-lon.de/
027
028 Department of Geography, University of Bonn
029 Prof. Dr. Klaus Greve
030 Postfach 1147, 53001 Bonn
031 Germany
032 http://www.geographie.uni-bonn.de/deegree/
033
034 e-mail: info@deegree.org
035 ----------------------------------------------------------------------------*/
036 package org.deegree.tools.raster;
037
038 import java.awt.color.ColorSpace;
039 import java.awt.image.BufferedImage;
040 import java.awt.image.ColorModel;
041 import java.awt.image.ComponentColorModel;
042 import java.awt.image.DataBuffer;
043 import java.awt.image.Raster;
044 import java.awt.image.WritableRaster;
045 import java.io.BufferedReader;
046 import java.io.File;
047 import java.io.FileOutputStream;
048 import java.io.FileReader;
049 import java.io.IOException;
050 import java.io.PrintStream;
051 import java.util.ArrayList;
052 import java.util.Arrays;
053 import java.util.Hashtable;
054 import java.util.List;
055 import java.util.StringTokenizer;
056
057 import org.deegree.datatypes.values.Interval;
058 import org.deegree.datatypes.values.TypedLiteral;
059 import org.deegree.datatypes.values.Values;
060 import org.deegree.framework.util.ConvenienceFileFilter;
061 import org.deegree.framework.util.ImageUtils;
062 import org.deegree.io.quadtree.IndexException;
063 import org.deegree.io.quadtree.MemPointQuadtree;
064 import org.deegree.io.quadtree.Quadtree;
065 import org.deegree.model.coverage.grid.WorldFile;
066 import org.deegree.model.spatialschema.Envelope;
067 import org.deegree.model.spatialschema.GeometryFactory;
068 import org.deegree.model.spatialschema.Point;
069 import org.deegree.processing.raster.interpolation.DataTuple;
070 import org.deegree.processing.raster.interpolation.InterpolationException;
071 import org.deegree.processing.raster.interpolation.InverseDistanceToPower;
072
073 /**
074 * This class converts geodata and special values from a simple text file format to a .tiff file
075 * format. The values are written as 32 bit float values. The <code>main</code> method should be
076 * used to utilise this class as a command line tool.
077 *
078 *
079 * @author <a href="mailto:schmitz@lat-lon.de">Andreas Schmitz</a>
080 * @author last edited by: $Author: mschneider $
081 *
082 * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
083 */
084 public class Text2Tiff {
085
086 // parameters
087 private int columnNumber = 0;
088
089 private double resolution = 0;
090
091 private String columnName = null;
092
093 private List<String> inputFilenames = new ArrayList<String>();
094
095 private String outputFilename = null;
096
097 private boolean readHeader = false;
098
099 private boolean oracle = false;
100
101 private Envelope boundingBox = null;
102
103 private boolean interpolate = false;
104
105 private boolean use32Bits = false;
106
107 // data
108 private BufferedReader in;
109
110 private Raster raster;
111
112 private Quadtree quadtree;
113
114 private BufferedImage image;
115
116 private int imageWidth;
117
118 private int imageHeight;
119
120 private DataBuffer buffer;
121
122 private float offset = 0;
123
124 // interpolating options
125 private double interpolatePower = 2;
126
127 private int interpolateMinData = 5;
128
129 private int interpolateMaxData = 20;
130
131 private double interpolateNoValue = 0;
132
133 private double interpolateRadiusX = 2;
134
135 private double interpolateRadiusY = 2;
136
137 private double interpolateRadiusIncreaseX = 0;
138
139 private double interpolateRadiusIncreaseY = 0;
140
141 private Values ignoreValues = null;
142
143 /**
144 * The only constructor, called usually by the main method with command line arguments.
145 *
146 * @param args
147 */
148 public Text2Tiff( String[] args ) {
149 if ( args.length < 3 ) {
150 printUsage( "Not enough arguments." );
151 }
152
153 parseArgs( args );
154
155 // check for consistency
156 if ( ( columnName != null ) && !readHeader ) {
157 printUsage( "If a column name is given, I have to read the header!" );
158 }
159
160 if ( inputFilenames.size() == 0 ) {
161 printUsage( "No input filename given." );
162 }
163
164 if ( outputFilename == null ) {
165 printUsage( "No output filename given." );
166 }
167
168 if ( columnName == null && columnNumber == 0 ) {
169 printUsage( "No column specified." );
170 }
171
172 if ( !readHeader ) {
173 --columnNumber;
174 }
175 }
176
177 private void parseArgs( String[] args ) {
178 List<Interval> intervals = new ArrayList<Interval>();
179
180 // parse options
181 try {
182 for ( int i = 0; i < ( args.length - 1 ); ++i ) {
183 if ( args[i].equals( "--image-type" ) ) {
184 use32Bits = args[i + 1].equals( "32" );
185 ++i;
186 } else if ( args[i].equals( "--offset" ) ) {
187 offset = Float.parseFloat( args[i + 1] );
188 ++i;
189 } else if ( args[i].equals( "--image-width" ) ) {
190 imageWidth = Integer.parseInt( args[i + 1] );
191 ++i;
192 } else if ( args[i].equals( "--image-height" ) ) {
193 imageHeight = Integer.parseInt( args[i + 1] );
194 ++i;
195 } else if ( args[i].equals( "-c" ) || args[i].equals( "--column-number" ) ) {
196 columnNumber = Integer.parseInt( args[i + 1] );
197 ++i;
198 } else if ( args[i].equals( "-h" ) || args[i].equals( "--no-read-header" ) ) {
199 readHeader = false;
200 } else if ( args[i].equals( "-o" ) || args[i].equals( "--oracle" ) ) {
201 oracle = true;
202 } else if ( args[i].equals( "+h" ) || args[i].equals( "--read-header" ) ) {
203 readHeader = true;
204 } else if ( args[i].equals( "-cn" ) || args[i].equals( "--column-name" ) ) {
205 columnName = args[i + 1];
206 ++i;
207 } else if ( args[i].equals( "-r" ) || args[i].equals( "--resolution" ) ) {
208 resolution = Double.parseDouble( args[i + 1] );
209 ++i;
210 } else if ( args[i].equals( "-i" ) || args[i].equals( "--interpolate" ) ) {
211 interpolate = true;
212 } else if ( args[i].equals( "--interpolate-power" ) ) {
213 interpolatePower = Double.parseDouble( args[i + 1] );
214 ++i;
215 } else if ( args[i].equals( "--interpolate-min-data" ) ) {
216 interpolateMinData = Integer.parseInt( args[i + 1] );
217 ++i;
218 } else if ( args[i].equals( "--interpolate-max-data" ) ) {
219 interpolateMaxData = Integer.parseInt( args[i + 1] );
220 ++i;
221 } else if ( args[i].equals( "--interpolate-no-value" ) ) {
222 interpolateNoValue = Double.parseDouble( args[i + 1] );
223 ++i;
224 } else if ( args[i].equals( "--interpolate-radius-x" ) ) {
225 interpolateRadiusX = Double.parseDouble( args[i + 1] );
226 ++i;
227 } else if ( args[i].equals( "--interpolate-radius-y" ) ) {
228 interpolateRadiusY = Double.parseDouble( args[i + 1] );
229 ++i;
230 } else if ( args[i].equals( "--interpolate-radius-increase-x" ) ) {
231 interpolateRadiusIncreaseX = Double.parseDouble( args[i + 1] );
232 ++i;
233 } else if ( args[i].equals( "--interpolate-radius-increase-y" ) ) {
234 interpolateRadiusIncreaseY = Double.parseDouble( args[i + 1] );
235 ++i;
236 } else if ( args[i].equals( "--interpolate-ignore-range" ) ) {
237 TypedLiteral min = new TypedLiteral( args[i + 1], null );
238 TypedLiteral max = new TypedLiteral( args[i + 2], null );
239 Interval interval = new Interval( min, max, null, null, null );
240 intervals.add( interval );
241 i += 2;
242 } else if ( args[i].equals( "--help" ) ) {
243 printUsage( null );
244 } else if ( args[i].equals( "-help" ) ) {
245 printUsage( null );
246 } else {
247 File file = new File( args[i] );
248 if ( file.isDirectory() ) {
249 File[] files = file.listFiles( new ConvenienceFileFilter( false, "XYZ,TXT" ) );
250 for ( int j = 0; j < files.length; j++ ) {
251 inputFilenames.add( files[j].getAbsolutePath() );
252 }
253 } else {
254 inputFilenames.add( args[i] );
255 }
256 }
257
258 }
259 } catch ( NumberFormatException nfe ) {
260 printUsage( "Illegal argument, number expected." );
261 }
262
263 // get file names
264 outputFilename = args[args.length - 1];
265 if ( intervals.size() != 0 ) {
266 ignoreValues = new Values( intervals.toArray( new Interval[intervals.size()] ), null, null );
267 }
268 }
269
270 // reads the first line
271 private void readHeader()
272 throws IOException {
273 if ( !readHeader ) {
274 return;
275 }
276
277 String s = in.readLine();
278
279 columnNumber = 0;
280
281 // get the right index for the column
282 if ( columnName != null ) {
283 StringTokenizer tok = new StringTokenizer( s );
284 while ( tok.hasMoreTokens() ) {
285 String t = tok.nextToken();
286 if ( t.equals( columnName ) ) {
287 break;
288 }
289 ++columnNumber;
290 }
291 } else {
292 --columnNumber;
293 }
294 }
295
296 // reads all data into the array lists
297 private ArrayList<DataTuple> readValues( String filename )
298 throws IOException, NumberFormatException {
299
300 readHeader();
301
302 File file = new File( filename );
303 int size = (int) ( file.length() / 30 );
304
305 ArrayList<DataTuple> values = new ArrayList<DataTuple>( size );
306 BufferedReader in = new BufferedReader( new FileReader( filename ) );
307 int counter = 0;
308 while ( in.ready() ) {
309 StringTokenizer tokenizer = new StringTokenizer( in.readLine() );
310 int idx = 0;
311 double x = 0;
312 double y = 0;
313 while ( tokenizer.hasMoreTokens() ) {
314 if ( idx == 0 ) {
315 x = Double.parseDouble( tokenizer.nextToken() );
316 } else if ( idx == 1 ) {
317 y = Double.parseDouble( tokenizer.nextToken() );
318 } else if ( idx == columnNumber ) {
319 values.add( new DataTuple( x, y, Double.parseDouble( tokenizer.nextToken() ) ) );
320 break;
321 } else
322 tokenizer.nextToken();
323 ++idx;
324 }
325 if ( ++counter % 10000 == 0 ) {
326 System.out.print( "Read " + counter / 1000 + " thousand lines.\r" );
327 }
328 }
329 System.out.println();
330 in.close();
331
332 return values;
333 }
334
335 // calculate resolution and bbox
336 private void preprocessFiles()
337 throws IOException {
338 double minx = Double.MAX_VALUE;
339 double miny = Double.MAX_VALUE;
340 double maxx = Double.MIN_VALUE;
341 double maxy = Double.MIN_VALUE;
342 boolean calcResolution = ( resolution == 0 );
343 if ( imageWidth != 0 && imageHeight != 0 ) {
344 calcResolution = false;
345 }
346
347 if ( calcResolution ) {
348 resolution = Double.MAX_VALUE;
349 }
350
351 for ( String filename : inputFilenames ) {
352 System.out.println( "Reading file " + filename );
353 ArrayList<DataTuple> values = readValues( filename );
354
355 // Collections.sort( values );
356
357 double[] ys = null;
358 DataTuple prev = null;
359 double cur;
360 if ( calcResolution ) {
361 ys = new double[values.size()];
362 prev = values.get( 0 );
363 cur = 0;
364 }
365
366 for ( int i = 0; i < values.size(); ++i ) {
367 DataTuple tuple = values.get( i );
368
369 if ( maxx < tuple.x ) {
370 maxx = tuple.x;
371 }
372 if ( maxy < tuple.y ) {
373 maxy = tuple.y;
374 }
375 if ( minx > tuple.x ) {
376 minx = tuple.x;
377 }
378 if ( miny > tuple.y ) {
379 miny = tuple.y;
380 }
381
382 if ( calcResolution ) {
383 cur = Math.abs( tuple.x - prev.x );
384 if ( ( cur != 0 ) && ( resolution > cur ) ) {
385 resolution = cur;
386 }
387 ys[i] = tuple.y;
388 prev = tuple;
389 }
390 }
391
392 if ( calcResolution ) {
393 Arrays.sort( ys );
394
395 for ( int i = 0; i < ys.length - 1; ++i ) {
396 cur = Math.abs( ys[i] - ys[i + 1] );
397 if ( cur != 0 && cur < resolution ) {
398 resolution = cur;
399 }
400 }
401 }
402 }
403
404 System.out.println( "Covered area:" );
405 System.out.println( minx + " - " + maxx );
406 System.out.println( miny + " - " + maxy );
407
408 boundingBox = GeometryFactory.createEnvelope( minx, miny, maxx, maxy, null );
409
410 if ( !calcResolution && resolution == 0 ) {
411 resolution = Math.abs( ( maxy - miny ) / ( imageHeight ) );
412 double h = Math.abs( ( maxx - minx ) / ( imageWidth ) );
413 if ( h < resolution ) {
414 resolution = h;
415 }
416 }
417 if ( imageWidth == 0 && imageHeight == 0 ) {
418 imageWidth = (int) ( boundingBox.getWidth() / resolution ) + 1;
419 imageHeight = (int) ( boundingBox.getHeight() / resolution ) + 1;
420 }
421
422 System.gc();
423
424 System.out.println( "Resolution: " + resolution );
425
426 }
427
428 // creates the buffered image with the right size
429 private void createImage() {
430
431 ColorModel ccm;
432
433 if ( use32Bits ) {
434 image = new BufferedImage( imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB );
435 } else {
436 ccm = new ComponentColorModel( ColorSpace.getInstance( ColorSpace.CS_GRAY ), null, false, false,
437 BufferedImage.OPAQUE, DataBuffer.TYPE_USHORT );
438 WritableRaster wr = ccm.createCompatibleWritableRaster( imageWidth, imageHeight );
439
440 image = new BufferedImage( ccm, wr, false, new Hashtable<Object, Object>() );
441 }
442
443 raster = image.getData();
444
445 buffer = raster.getDataBuffer();
446
447 }
448
449 // calculates the index of the desired position (in regard to a DataBuffer of a Raster)
450 private int calculatePosition( double x, double y ) {
451
452 double tmp = ( x - boundingBox.getMin().getX() ) / resolution;
453
454 double ypos = imageHeight - ( ( y - boundingBox.getMin().getY() ) / resolution ) - 1;
455 return (int) Math.round( tmp + ( ypos * imageWidth ) );
456
457 }
458
459 // inserts all values into the image
460 private void insertValue( double x, double y, double val ) {
461
462 int pos = Math.abs( calculatePosition( x, y ) );
463 if ( use32Bits ) {
464 buffer.setElem( pos, Float.floatToIntBits( ( (float) val ) + offset ) );
465 } else {
466 buffer.setElem( pos, (int) Math.round( ( ( val + offset ) * 10 ) ) );
467 }
468
469 }
470
471 // creates the worldfile, depends on minimum values (call after createImage)
472 private void writeWorldfile()
473 throws IOException {
474 if ( oracle ) {
475 PrintStream out = new PrintStream( new FileOutputStream( outputFilename + ".tfw" ) );
476 out.println( resolution );
477 out.println( "0.0" );
478 out.println( "0.0" );
479 out.println( -resolution );
480 if ( oracle ) {
481 out.println( boundingBox.getMin().getX() - resolution / 2 );
482 } else {
483 out.println( boundingBox.getMin().getX() );
484 }
485 if ( oracle ) {
486 out.println( boundingBox.getMax().getY() + resolution / 2 );
487 } else {
488 out.println( boundingBox.getMax().getY() );
489 }
490 out.println();
491 } else {
492 WorldFile wf = new WorldFile( resolution, -resolution, 0, 0, boundingBox );
493 WorldFile.writeWorldFile( wf, outputFilename );
494 }
495 }
496
497 private void buildQuadtree()
498 throws IOException, IndexException {
499 for ( String filename : inputFilenames ) {
500 readHeader();
501
502 BufferedReader in = new BufferedReader( new FileReader( filename ) );
503 int counter = 0;
504 while ( in.ready() ) {
505 StringTokenizer tokenizer = new StringTokenizer( in.readLine() );
506 int idx = 0;
507 double x = 0;
508 double y = 0;
509 while ( tokenizer.hasMoreTokens() ) {
510 if ( idx == 0 ) {
511 x = Double.parseDouble( tokenizer.nextToken() );
512 } else if ( idx == 1 ) {
513 y = Double.parseDouble( tokenizer.nextToken() );
514 } else if ( idx == columnNumber ) {
515 Point point = GeometryFactory.createPoint( x, y, null );
516 quadtree.insert( new DataTuple( x, y, Double.parseDouble( tokenizer.nextToken() ) ), point );
517 break;
518 } else
519 tokenizer.nextToken();
520 ++idx;
521 }
522 if ( ++counter % 10000 == 0 ) {
523 System.out.print( "Read " + counter / 1000 + " thousand lines.\r" );
524 }
525 }
526 in.close();
527 System.out.println();
528
529 }
530
531 }
532
533 /**
534 * This method executes all steps that are required to transform the text file into a tiff file.
535 *
536 */
537 private void transform() {
538 try {
539 preprocessFiles();
540
541 quadtree = new MemPointQuadtree( boundingBox );
542
543 buildQuadtree();
544
545 createImage();
546
547 interpolate();
548
549 image.setData( raster );
550
551 System.out.println( "Writing output files..." );
552 ImageUtils.saveImage( image, new File( outputFilename + ".tif" ), 1 );
553 writeWorldfile();
554 System.out.println( "Done." );
555 // testOutput();
556 } catch ( IOException ioe ) {
557 System.out.println( "Could not read or write a file, reason:" );
558 ioe.printStackTrace();
559 System.exit( 0 );
560 } catch ( NumberFormatException nfe ) {
561 System.out.println( "A number could not be parsed correctly. Reason: " );
562 nfe.printStackTrace();
563 System.exit( 0 );
564 } catch ( InterpolationException e ) {
565 System.out.println( "Could not interpolate missing values. Reason: " );
566 e.printStackTrace();
567 System.exit( 0 );
568 } catch ( IndexException e ) {
569 System.out.println( "Could not build Quadtree. Reason: " );
570 e.printStackTrace();
571 System.exit( 0 );
572 }
573 }
574
575 private void interpolate()
576 throws InterpolationException {
577
578 InverseDistanceToPower interpolator = new InverseDistanceToPower( quadtree, ignoreValues, interpolateRadiusX,
579 interpolateRadiusY, 0, interpolateMinData,
580 interpolateMaxData, interpolateNoValue,
581 interpolateRadiusIncreaseX,
582 interpolateRadiusIncreaseY, interpolatePower );
583
584 double minx = boundingBox.getMin().getX();
585 double miny = boundingBox.getMin().getY();
586
587 int count = imageWidth * imageHeight;
588
589 int counter = 0;
590
591 int interpolatedCounter = 0;
592
593 for ( int xipos = 0; xipos < imageWidth; ++xipos ) {
594 for ( int yipos = 0; yipos < imageHeight; ++yipos ) {
595 double xpos = minx + resolution * xipos;
596 double ypos = miny + resolution * yipos;
597
598 Envelope env = GeometryFactory.createEnvelope( xpos - 0.01, ypos - 0.01, xpos + 0.01, ypos + 0.01, null );
599
600 try {
601 List<?> list = quadtree.query( env );
602 double val = 0;
603 if ( list.size() == 0 ) {
604 if ( interpolate ) {
605 val = interpolator.calcInterpolatedValue( xpos, ypos, interpolateRadiusX,
606 interpolateRadiusY );
607 ++interpolatedCounter;
608 }
609 } else {
610 val = ( (DataTuple) list.get( 0 ) ).value;
611 }
612
613 insertValue( xpos, ypos, val );
614
615 } catch ( IndexException e ) {
616 throw new InterpolationException( "Could not interpolate.", e );
617 }
618
619 if ( ++counter % 1000 == 0 ) {
620 System.out.print( counter + "/" + count + "\r" );
621 }
622 }
623 }
624
625 System.out.println( counter + '/' + count + ", interpolated " + interpolatedCounter + " values" );
626 }
627
628 /**
629 * Prints out an error message and general usage information of the tool.
630 *
631 * @param error
632 * an error message
633 */
634 public void printUsage( String error ) {
635 if ( error != null ) {
636 System.out.println( "Error: " + error );
637 System.out.println();
638 }
639 System.out.println( "java Text2Tiff <options> <inputfile[s]> <outputfile>" );
640 System.out.println( "Options:" );
641 System.out.println();
642 System.out.println( " --help, -help:" );
643 System.out.println( " print this message" );
644 System.out.println( " --read-header, +h:" );
645 System.out.println( " --no-read-header, -h:" );
646 System.out.println( " Do/Do not read a header line in the input file. If enabled," );
647 System.out.println( " one can specify column names instead of column numbers as" );
648 System.out.println( " seen below. Default is no." );
649 System.out.println( " --column-number n, -c n:" );
650 System.out.println( " Use the column number n as input column. Must be specified" );
651 System.out.println( " if column name below is not given. Counting starts with one," );
652 System.out.println( " so '3' means actually the third column, not the fourth." );
653 System.out.println( " --column-name n, -cn n:" );
654 System.out.println( " Use the column named n as input column. Must be specified" );
655 System.out.println( " if no column number is given." );
656 System.out.println( " --oracle, -o:" );
657 System.out.println( " Write the worldfile as Oracle expects it, using the outer" );
658 System.out.println( " bounds of the bbox and not the point centers. Default is no." );
659 System.out.println( " --image-type n:" );
660 System.out.println( " n can be either 16 or 32. If n is 16, an image of type USHORT" );
661 System.out.println( " will be created, and the values will be stored as shorts," );
662 System.out.println( " multiplied by 10. If n is 32, the float values will be" );
663 System.out.println( " stored in an image of type integer, as can be seen in" );
664 System.out.println( " Java's Float.floatToIntBits() method. Default is 16." );
665 System.out.println( " --image-width n:" );
666 System.out.println( " --image-height n:" );
667 System.out.println( " If set, an image of this size will be created. If not set" );
668 System.out.println( " (default), the size will be determined by the resolution" );
669 System.out.println( " either determined automatically or set by hand." );
670 System.out.println( " --offset n:" );
671 System.out.println( " use this as offset value for the result tiff. If result tiff" );
672 System.out.println( " shall be a 16Bit tiff first offset will be added to value" );
673 System.out.println( " before it will be multiplyed by 10" );
674 System.out.println( " --resolution n, -r n:" );
675 System.out.println( " Set geo resolution to n. If omitted, the resolution will be" );
676 System.out.println( " set to the smallest value found in the input data." );
677 System.out.println( " --interpolate, i:" );
678 System.out.println( " Interpolate missing values. By default, no interpolation" );
679 System.out.println( " will be performed." );
680 System.out.println( " --interpolate-power n:" );
681 System.out.println( " Interpolate using n as power. Default is " + interpolatePower + "." );
682 System.out.println( " --interpolate-min-data n:" );
683 System.out.println( " Interpolate only in the presence of n values within the search" );
684 System.out.println( " radius. Default is " + interpolateMinData + "." );
685 System.out.println( " --interpolate-max-data n:" );
686 System.out.println( " Interpolate using a maximum of n values from within the search" );
687 System.out.println( " radius. If more values are found, the n nearest will be used." );
688 System.out.println( " Default is " + interpolateMaxData + "." );
689 System.out.println( " --interpolate-no-value n:" );
690 System.out.println( " The value to be used if insufficient data is in the search" );
691 System.out.println( " radius. See also the radius-increase options below. Default" );
692 System.out.println( " is " + interpolateNoValue + "." );
693 System.out.println( " --interpolate-radius-x n:" );
694 System.out.println( " Interpolate using a search radius of n in the x direction." );
695 System.out.println( " Default is " + interpolateRadiusX + "." );
696 System.out.println( " --interpolate-radius-y n:" );
697 System.out.println( " Interpolate using a search radius of n in the y direction." );
698 System.out.println( " Default is " + interpolateRadiusY + "." );
699 System.out.println( " --interpolate-radius-increase-x n:" );
700 System.out.println( " Automatically increase the x search radius by n if less than" );
701 System.out.println( " --i-min-data values are found. If specified and not 0, the" );
702 System.out.println( " value --i-no-value will be ignored. Default is 0." );
703 System.out.println( " --interpolate-radius-increase-y n:" );
704 System.out.println( " Automatically increase the y search radius by n if less than" );
705 System.out.println( " --i-min-data values are found. If specified and not 0, the" );
706 System.out.println( " value --i-no-value will be ignored. Default is 0." );
707 System.out.println( " --interpolate-ignore-range min max:" );
708 System.out.println( " Adds a new range of values to be ignored while interpolating." );
709 System.out.println();
710 System.out.println( ".tif/.tfw will be appended to the <outputfile> parameter." );
711 System.out.println();
712
713 if ( error == null ) {
714 System.exit( 0 );
715 } else {
716 System.exit( 1 );
717 }
718 }
719
720 /**
721 * This method is used from the command line.
722 *
723 * @param args
724 * the command line arguments.
725 */
726 public static void main( String[] args ) {
727 new Text2Tiff( args ).transform();
728 }
729
730 }