    001    //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.4_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    }