001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/io/geotiff/GeoTiffReader.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.io.geotiff;
037
038 import java.io.File;
039 import java.io.FileInputStream;
040 import java.io.FileNotFoundException;
041 import java.io.IOException;
042 import java.util.HashMap;
043 import java.util.StringTokenizer;
044
045 import org.apache.batik.ext.awt.image.codec.FileCacheSeekableStream;
046 import org.apache.batik.ext.awt.image.codec.tiff.TIFFDecodeParam;
047 import org.apache.batik.ext.awt.image.codec.tiff.TIFFDirectory;
048 import org.apache.batik.ext.awt.image.codec.tiff.TIFFField;
049 import org.apache.batik.ext.awt.image.codec.tiff.TIFFImage;
050 import org.deegree.framework.log.ILogger;
051 import org.deegree.framework.log.LoggerFactory;
052 import org.deegree.model.spatialschema.Envelope;
053 import org.deegree.model.spatialschema.GeometryFactory;
054
055 /**
056 * <p>
057 * <tt>
058 * TIFF type :: Java type<br>
059 * TIFF_BYTE :: byte<br>
060 * TIFF_ASCII :: String<br>
061 * TIFF_SHORT :: char<br>
062 * TIFF_LONG :: long<br>
063 * TIFF_RATIONAL :: long[2]<br>
064 * TIFF_SBYTE :: byte<br>
065 * TIFF_UNDEFINED :: byte<br>
066 * TIFF_SSHORT :: short<br>
067 * TIFF_SLONG :: int<br>
068 * TIFF_SRATIONAL :: int[2]<br>
069 * TIFF_FLOAT :: float<br>
070 * TIFF_DOUBLE :: double<br>
071 * </tt>
072 * <p>
073 *
074 * @author <a href="mailto:schaefer@lat-lon.de">Axel Schaefer </A>
075 * @author last edited by: $Author: mschneider $
076 * @version 2.0. $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
077 * @since
078 */
079 public class GeoTiffReader {
080
081 private static final ILogger LOG = LoggerFactory.getLogger( GeoTiffReader.class );
082
083 TIFFImage image = null;
084
085 TIFFDirectory tifdir = null;
086
087 HashMap<Integer, int[]> geoKeyDirectoryTag = null;
088
089 boolean hasGeoKeyDirectoryTag = false;
090
091 /**
092 * @param file
093 * @throws FileNotFoundException
094 * @throws IOException
095 * @throws GeoTiffException
096 */
097 public GeoTiffReader( File file ) throws FileNotFoundException, IOException, GeoTiffException {
098
099 TIFFDecodeParam decodeParam = new TIFFDecodeParam();
100 int geodirectory = 0;
101
102 FileInputStream fis = new FileInputStream( file );
103 FileCacheSeekableStream fcss = new FileCacheSeekableStream( fis );
104 this.image = new TIFFImage( fcss, decodeParam, geodirectory );
105
106 if ( !isGeoTiff( this.image ) ) {
107 throw new GeoTiffException( "GeoTiffReader: TIFF is no GeoTIFF image!" );
108 }
109
110 this.tifdir = (TIFFDirectory) image.getProperty( "tiff_directory" );
111
112 if ( this.tifdir.getField( GeoTiffTag.GeoKeyDirectoryTag ) != null ) {
113 setGeoKeyDirectoryTag();
114 }
115 fcss.close();
116
117 }
118
119 // ***********************************************************************
120 // General GeoTIFF tags
121 // ***********************************************************************
122
123 /**
124 * <p>
125 * GeoKeyDirectoryTag: <br>
126 * Tag = 34735 (87AF.H) <br>
127 * Type = SHORT (2-byte unsigned short) <br>
128 * N = variable, >= 4 <br>
129 * Alias: ProjectionInfoTag, CoordSystemInfoTag <br>
130 * Owner: SPOT Image, Inc.
131 * <p>
132 * This tag may be used to store the GeoKey Directory, which defines and references the
133 * "GeoKeys", as described below.
134 * <p>
135 * The tag is an array of unsigned SHORT values, which are primarily grouped into blocks of 4.
136 * The first 4 values are special, and contain GeoKey directory header information. The header
137 * values consist of the following information, in order:
138 * <p>
139 * <tt>Header={KeyDirectoryVersion, KeyRevision, MinorRevision, NumberOfKeys}</tt>
140 * <p>
141 * and as Keys:
142 * <p>
143 * <tt>KeyEntry = { KeyID, TIFFTagLocation, Count, Value_Offset }</tt>^
144 * <p>
145 * where
146 * <ul>
147 * <li>"KeyID" gives the key-ID value of the Key (identical in function to TIFF tag ID, but
148 * completely independent of TIFF tag-space),
149 * <li>"TIFFTagLocation" indicates which TIFF tag contains the value(s) of the Key: if
150 * TIFFTagLocation is 0, then the value is SHORT, and is contained in the "Value_Offset" entry.
151 * Otherwise, the type (format) of the value is implied by the TIFF-Type of the tag containing
152 * the value.
153 * <li>"Count" indicates the number of values in this key.
154 * <li>"Value_Offset" Value_Offset indicates the index- offset *into* the TagArray indicated by
155 * TIFFTagLocation, if it is nonzero. If TIFFTagLocation=0, then Value_Offset contains the
156 * actual (SHORT) value of the Key, and Count=1 is implied. Note that the offset is not a
157 * byte-offset, but rather an index based on the natural data type of the specified tag array.</li>
158 * </ul>
159 */
160 private void setGeoKeyDirectoryTag() {
161 TIFFField ff = this.tifdir.getField( GeoTiffTag.GeoKeyDirectoryTag );
162
163 char[] ch = ff.getAsChars();
164
165 // resulting HashMap, containing the key and the array of values
166 this.geoKeyDirectoryTag = new HashMap<Integer, int[]>( ff.getCount() / 4 );
167 // array of values. size is 4-1.
168
169 int keydirversion, keyrevision, minorrevision, numberofkeys = -99;
170
171 for ( int i = 0; i < ch.length; i = i + 4 ) {
172 int[] keys = new int[3];
173 keydirversion = ch[i];
174
175 keyrevision = ch[i + 1];
176 minorrevision = ch[i + 2];
177 numberofkeys = ch[i + 3];
178 keys[0] = keyrevision;
179 keys[1] = minorrevision;
180 keys[2] = numberofkeys;
181
182 LOG.logDebug( "[" + i + "].KEY: " + keydirversion + " \t" + keyrevision + "\t" + minorrevision + "\t"
183 + numberofkeys );
184 this.geoKeyDirectoryTag.put( new Integer( keydirversion ), keys );
185 }
186 this.hasGeoKeyDirectoryTag = true;
187 }
188
189 /**
190 * <p>
191 * GeoDoubleParamsTag: <br>
192 * Tag = 34736 (87BO.H) <br>
193 * Type = DOUBLE (IEEE Double precision) <br>
194 * N = variable <br>
195 * Owner: SPOT Image, Inc.
196 * <p>
197 * This tag is used to store all of the DOUBLE valued GeoKeys, referenced by the
198 * GeoKeyDirectoryTag. The meaning of any value of this double array is determined from the
199 * GeoKeyDirectoryTag reference pointing to it. FLOAT values should first be converted to DOUBLE
200 * and stored here.
201 *
202 * @return null
203 */
204 public Object getGeoDoubleParamsTag() {
205 // TIFFField ff = this.tifdir.getField(GeoTiffTag.GeoDoubleParamsTag);
206 // TODO GeoDoubleParamsTag
207 return null;
208 }
209
210 /**
211 * <p>
212 * GeoAsciiParamsTag: <br>
213 * Tag = 34737 (87B1.H) <br>
214 * Type = ASCII <br>
215 * Owner: SPOT Image, Inc. <br>
216 * N = variable
217 * <p>
218 * This tag is used to store all of the DOUBLE valued GeoKeys, referenced by the
219 * GeoKeyDirectoryTag. The meaning of any value of this double array is determined from the
220 * GeoKeyDirectoryTag reference pointing to it. FLOAT values should first be converted to DOUBLE
221 * and stored here.
222 * <p>
223 * A baseline GeoTIFF-reader must check for and convert the final "|" pipe character of a key
224 * back into a NULL before returning it to the client software.
225 *
226 * @return the fields
227 *
228 */
229 public String[] getGeoAsciiParamsTag() {
230
231 // TODO: getGeoAsciiParamsTag(int count, int value_offset)!!!
232
233 TIFFField field = this.tifdir.getField( GeoTiffTag.GeoAsciiParamsTag );
234 String gapt = field.getAsString( 0 );
235
236 LOG.logDebug( gapt );
237
238 StringTokenizer st = new StringTokenizer( gapt, "|" );
239
240 LOG.logDebug( "countTokens: " + st.countTokens() );
241
242 String[] gapt_fields = new String[st.countTokens()];
243 int i = 0;
244 while ( st.hasMoreTokens() ) {
245 gapt_fields[i++] = st.nextToken();
246 }
247
248 for ( int j = 0; j < gapt_fields.length; j++ ) {
249 LOG.logDebug( gapt_fields[j] );
250 }
251
252 return gapt_fields;
253 }
254
255 // ***********************************************************************
256 // specific GeoTIFF contents GeoTIFF keys
257 // ***********************************************************************
258 /**
259 *
260 */
261 private int[] getVersionInformation()
262 throws GeoTiffException {
263
264 int[] content = new int[3];
265 if ( this.geoKeyDirectoryTag.containsKey( new Integer( 1 ) ) ) {
266 content = this.geoKeyDirectoryTag.get( new Integer( 1 ) );
267 } else {
268 throw new GeoTiffException( "No GeoTIFF Information found at Tag '1'" );
269 }
270 return content;
271 }
272
273 /**
274 *
275 * @return fixed 1
276 * @throws GeoTiffException
277 */
278 public int getGeoKeyDirectoryVersion()
279 throws GeoTiffException {
280 getVersionInformation();
281 return 1;
282 }
283
284 /**
285 *
286 * @return the rev
287 * @throws GeoTiffException
288 */
289 public String getKeyRevision()
290 throws GeoTiffException {
291 String key_revision = "";
292 int[] kv = getVersionInformation();
293 key_revision = kv[0] + "." + kv[1];
294 return key_revision;
295 }
296
297 /**
298 * @return the number
299 * @throws GeoTiffException
300 */
301 public int getNumberOfKeysInGeoKeyDirectoryTag()
302 throws GeoTiffException {
303 int[] kv = getVersionInformation();
304 return kv[2];
305 }
306
307 /**
308 * <p>
309 * Key ID = 1024 <br>
310 * Type: SHORT (code) <br>
311 * <p>
312 * This GeoKey defines the general type of model Coordinate system used, and to which the raster
313 * space will be transformed:unknown, Geocentric (rarely used), Geographic, Projected Coordinate
314 * System, or user-defined. If the coordinate system is a PCS, then only the PCS code need be
315 * specified. If the coordinate system does not fit into one of the standard registered PCS'S,
316 * but it uses one of the standard projections and datums, then its should be documented as a
317 * PCS model with "user-defined" type, requiring the specification of projection parameters,
318 * etc.
319 * <p>
320 * GeoKey requirements for User-Defined Model Type (not advisable): GTCitationGeoKey
321 *
322 * @return (0) unknown, <br>
323 * (1) ModelTypeProjected (Projection Coordinate System), <br>
324 * (2) ModelTypeGeographic (Geographic latitude-longitude System), <br>
325 * (3) ModelTypeGeocentric (Geocentric (X,Y,Z) Coordinate System) (rarely used), <br>
326 * (4?) user-defined
327 *
328 * @throws GeoTiffException
329 */
330 public int getGTModelTypeGeoKey()
331 throws GeoTiffException {
332 int[] content = new int[3];
333 int key = -99;
334
335 if ( this.geoKeyDirectoryTag.containsKey( new Integer( GeoTiffKey.GTModelTypeGeoKey ) ) ) {
336 content = this.geoKeyDirectoryTag.get( new Integer( GeoTiffKey.GTModelTypeGeoKey ) );
337
338 // TIFFTagLocation
339 if ( content[0] == 0 ) {
340 // return Value_Offset
341 key = content[2];
342 } else {
343 // TODO other TIFFTagLocation that GeoKeyDirectoryTag
344 }
345 } else {
346 throw new GeoTiffException( "No GeoTIFF Information found at Tag '" + GeoTiffKey.GTModelTypeGeoKey + "'" );
347 }
348 return key;
349 }
350
351 /**
352 *
353 * @throws GeoTiffException
354 */
355 public void getCoordinateSystem()
356 throws GeoTiffException {
357
358 if ( getGTModelTypeGeoKey() == 1 ) {
359 // getModelTypeProjected();
360 } else if ( getGTModelTypeGeoKey() == 2 ) {
361 // getModelTypeGeographic();
362 } else if ( getGTModelTypeGeoKey() == 3 ) {
363 // getModelTypeGeocentric();
364 } else {
365 // user-defined?
366 }
367
368 }
369
370 /**
371 *
372 * @return the bbox
373 * @throws GeoTiffException
374 */
375 public Envelope getBoundingBox()
376 throws GeoTiffException {
377
378 TIFFField modelPixelScaleTag = this.tifdir.getField( GeoTiffTag.ModelPixelScaleTag );
379 double resx = modelPixelScaleTag.getAsDouble( 0 );
380 double resy = modelPixelScaleTag.getAsDouble( 1 );
381
382 TIFFField modelTiepointTag = this.tifdir.getField( GeoTiffTag.ModelTiepointTag );
383 double val1 = 0.0;
384 val1 = modelTiepointTag.getAsDouble( 0 );
385 double val2 = 0.0;
386 val2 = modelTiepointTag.getAsDouble( 1 );
387 double val4 = 0.0;
388 val4 = modelTiepointTag.getAsDouble( 3 );
389 double val5 = 0.0;
390 val5 = modelTiepointTag.getAsDouble( 4 );
391
392 if ( ( resx == 0.0 || resy == 0.0 ) || ( val1 == 0.0 && val2 == 0.0 && val4 == 0.0 && val5 == 0.0 ) ) {
393 throw new GeoTiffException( "The image/coverage hasn't a bounding box" );
394 // set the geoparams derived by geoTiffTags
395 }
396
397 // upper/left pixel
398 double xOrigin = val4 - ( val1 * resx );
399 double yOrigin = val5 - ( val2 * resy );
400
401 // lower/right pixel
402 double xRight = xOrigin + image.getWidth() * resx;
403 double yBottom = yOrigin - image.getHeight() * resy;
404
405 double xmin = xOrigin;
406 double ymin = yBottom;
407 double xmax = xRight;
408 double ymax = yOrigin;
409
410 Envelope envelope = GeometryFactory.createEnvelope( xmin, ymin, xmax, ymax, null );
411
412 return envelope;
413 }
414
415 /**
416 *
417 * @return the crs
418 */
419 public String getHumanReadableCoordinateSystem() {
420
421 String ret = "";
422
423 if ( this.geoKeyDirectoryTag.containsKey( new Integer( GeoTiffKey.PCSCitationGeoKey ) ) ) {
424
425 int[] key_entry = this.geoKeyDirectoryTag.get( new Integer( GeoTiffKey.PCSCitationGeoKey ) );
426
427 // check if value of field is located in GeoAsciiParamsTag (34737)
428 if ( key_entry[0] == GeoTiffTag.GeoAsciiParamsTag ) {
429 TIFFField field = this.tifdir.getField( GeoTiffTag.GeoAsciiParamsTag );
430
431 int ascii_length = key_entry[1];
432 int ascii_start = key_entry[2];
433
434 // return the string between the two byte-locations - 1 (the
435 // last '|')
436 ret = "Projected CS: " + field.getAsString( 0 ).substring( ascii_start, ascii_length - 1 );
437
438 } else {
439 ret = "value of field is NOT located in GeoAsciiParamsTag (34737).";
440 }
441 } else {
442 ret = "<empty>";
443 }
444
445 // GeogCitationGeoKey
446
447 return ret;
448 }
449
450 // ***********************************************************************
451 // various GeoTiffReader methods
452 // ***********************************************************************
453
454 /**
455 * <p>
456 * description: the following TIFFKeys count as indicator if a TIFF-File carries GeoTIFF
457 * information: <br>
458 * ModelPixelScaleTag = 33550 (SoftDesk) <br>
459 * ModelTransformationTag = 34264 (JPL Carto Group) <br>
460 * ModelTiepointTag = 33922 (Intergraph) <br>
461 * GeoKeyDirectoryTag = 34735 (SPOT) <br>
462 * GeoDoubleParamsTag = 34736 (SPOT) <br>
463 * GeoAsciiParamsTag = 34737 (SPOT)
464 */
465 private boolean isGeoTiff( TIFFImage image ) {
466 TIFFDirectory directory = (TIFFDirectory) image.getProperty( "tiff_directory" );
467
468 if ( directory.getField( GeoTiffTag.ModelPixelScaleTag ) == null
469 && directory.getField( GeoTiffTag.ModelTransformationTag ) == null
470 && directory.getField( GeoTiffTag.ModelTiepointTag ) == null
471 && directory.getField( GeoTiffTag.GeoKeyDirectoryTag ) == null
472 && directory.getField( GeoTiffTag.GeoDoubleParamsTag ) == null
473 && directory.getField( GeoTiffTag.GeoAsciiParamsTag ) == null ) {
474 return false;
475 }
476 return true;
477 }
478
479 /**
480 *
481 * @return the image
482 * @throws GeoTiffException
483 */
484 public TIFFImage getTIFFImage()
485 throws GeoTiffException {
486 if ( this.image != null ) {
487 return this.image;
488 }
489 throw new GeoTiffException( "no image" );
490 }
491
492 /**
493 *
494 */
495 @Override
496 public String toString() {
497 String ret = "GeoTIFF Information:\n";
498
499 if ( hasGeoKeyDirectoryTag ) {
500
501 // Version Information
502 try {
503 ret += " Version: " + getGeoKeyDirectoryVersion() + "\n";
504 ret += " Key_Revision: " + getKeyRevision() + "\n";
505 ret += " Number Of Keys in GeoKeyDirectoryTag: " + getNumberOfKeysInGeoKeyDirectoryTag() + "\n";
506 ret += " GTModelTypeGeoKey: " + getGTModelTypeGeoKey() + "\n";
507
508 } catch ( GeoTiffException e ) {
509 ret += "GeoTiffException occured when requesting GeoTIFF Version Information:\n" + e.getMessage();
510 }
511
512 ret += "\n";
513 ret += "Coordinate System (human readable): " + getHumanReadableCoordinateSystem() + "\n";
514 ret += "\n";
515 } else {
516 ret += "\nNo GeoKeyDirectoryTag (34735) specified.\n";
517 }
518
519 if ( this.tifdir.getField( GeoTiffTag.ModelPixelScaleTag ) != null
520 || this.tifdir.getField( GeoTiffTag.ModelTiepointTag ) != null ) {
521
522 ret += "Corner Coordinates:\n";
523 try {
524 Envelope envelope = getBoundingBox();
525 ret += " Upper Left ( " + envelope.getMin().getX() + ", " + envelope.getMax().getY() + " )\n"
526 + " Lower Left ( " + envelope.getMin().getX() + ", " + envelope.getMin().getY() + " )\n"
527 + " Upper Right ( " + envelope.getMax().getX() + ", " + envelope.getMax().getY() + " )\n"
528 + " Lower Right ( " + envelope.getMax().getX() + ", " + envelope.getMin().getY() + " )\n";
529 } catch ( GeoTiffException e ) {
530 ret += "GeoTiffException occured when calculation the BoundingBox:\n" + e.getMessage();
531 }
532 } else {
533 ret += "\nNo BoundingBox Information in ModelPixelScaleTag (33550) and ModelTiepointTag (33922).\n"
534 + "ModelTransformationTag (34264) not implemented. \n" + "Here is a list of the available tags:\n";
535
536 for ( int i = 0; i < this.tifdir.getFields().length; i++ ) {
537 ret += " tag: " + this.tifdir.getFields()[i].getTag() + " \t type: "
538 + this.tifdir.getFields()[i].getType() + " \t count: " + this.tifdir.getFields()[i].getCount()
539 + "\n";
540 }
541
542 }
543
544 return ret;
545 }
546
547 }