gov/nasa/worldwind/formats/nitfs/NitfsMessage.java

   1 package gov.nasa.worldwind.formats.nitfs;
   2
   3 import gov.nasa.worldwind.*;
   4 import gov.nasa.worldwind.formats.rpf.*;
   5
   6 import java.io.*;
   7 import java.text.*;
   8 /*
   9 Copyright (C) 2001, 2007 United States Government
  10 as represented by the Administrator of the
  11 National Aeronautics and Space Administration.
  12 All Rights Reserved.
  13 */
  14
  15 /**
  16  * @author Lado Garakanidze
  17  * @version $Id: NitfsMessage Apr 4, 2007 4:11:55 PM lado
  18  */
  19 public class NitfsMessage
  20 {
  21     private     java.nio.ByteBuffer     buffer;
  22     private     NitfsFileHeader         fileHeader;
  23     private     java.util.ArrayList<NitfsSegment> segments = new java.util.ArrayList<NitfsSegment>();
  24
  25
  26     public NitfsSegment getSegment( NitfsSegmentType segmentType )
  27     {
  28         for(NitfsSegment seg : segments)
  29         {
  30             if(null != seg && seg.segmentType.equals(segmentType))
  31                 return seg;
  32         }
  33         return null;
  34     }
  35
  36     public  NitfsFileHeader getNitfsFileHeader()
  37     {
  38         return this.fileHeader;
  39     }
  40
  41     private NitfsMessage(java.nio.ByteBuffer buffer)
  42     {
  43         this.buffer = buffer;
  44         this.fileHeader = new NitfsFileHeader(buffer);
  45
  46         // read ALL description groups and segments
  47         this.readSegments();
  48     }
  49
  50     private void readSegments()
  51     {
  52         int saveOffset = this.buffer.position();
  53         int nextSegmentOffset = this.fileHeader.getHeaderLength();
  54
  55         // parse Image Description Group
  56         nextSegmentOffset = parseSegment(NitfsSegmentType.ImageSegment, nextSegmentOffset);
  57         // parse Graphic/Symbol Description Group
  58         nextSegmentOffset = parseSegment(NitfsSegmentType.SymbolSegment, nextSegmentOffset);
  59         // parse Label Description Group
  60         nextSegmentOffset = parseSegment(NitfsSegmentType.LabelSegment, nextSegmentOffset);
  61         // parse Text Description Group
  62         nextSegmentOffset = parseSegment(NitfsSegmentType.TextSegment, nextSegmentOffset);
  63         // parse Data Extension Description Group
  64         nextSegmentOffset = parseSegment(NitfsSegmentType.DataExtensionSegment, nextSegmentOffset);
  65         // parse Reserved Extension Description Group
  66         nextSegmentOffset = parseSegment(NitfsSegmentType.ReservedExtensionSegment, nextSegmentOffset);
  67         // parse User Defined Header Description (UDHD) Group
  68         NitfsUserDefinedHeaderSegment userHeaderSeg = new RpfUserDefinedHeaderSegment(this.buffer);
  69         this.segments.add( userHeaderSeg );
  70         nextSegmentOffset += userHeaderSeg.headerLength + userHeaderSeg.dataLength;
  71         // parse Extended Header Description Group
  72         nextSegmentOffset = parseSegment(NitfsSegmentType.ExtendedHeaderSegment, nextSegmentOffset);
  73
  74         // let's read each header
  75         for(NitfsSegment segment : segments)
  76         {
  77
  78 //
  79 //            String segId = NitfsUtil.getString(buffer, segment.headerStartOffset, 2);
  80 //            System.out.println("Segment type=" + segment.segmentType + ", id=" + segId);
  81         }
  82     }
  83
  84     private int parseSegment(NitfsSegmentType segType, int nextSegmentOffset)
  85     {
  86         int headerLengthSize = segType.getHeaderLengthSize();
  87         int dataLengthSize = segType.getDataLengthSize();
  88
  89         int numOfSegments = Integer.parseInt(NitfsUtil.getString(this.buffer, 3));
  90         for (int i = 0; i < numOfSegments; i++)
  91         {
  92             int segHeaderLength = Integer.parseInt(NitfsUtil.getString(this.buffer, headerLengthSize));
  93             int seqDataLength = Integer.parseInt(NitfsUtil.getString(this.buffer, dataLengthSize));
  94
  95             int saveOffset = this.buffer.position(); // pass buffer to NitfsSegment to parse their headers' contents
  96             NitfsSegment segment;
  97             switch (segType)
  98             {
  99                 case ImageSegment:
 100                     segment = new NitfsImageSegment(this.buffer, nextSegmentOffset, segHeaderLength,
 101                                         nextSegmentOffset + segHeaderLength, seqDataLength);
 102                     break;
 103                 case SymbolSegment:
 104                     segment = new NitfsSymbolSegment(this.buffer, nextSegmentOffset, segHeaderLength,
 105                                         nextSegmentOffset + segHeaderLength, seqDataLength);
 106                     break;
 107                 case LabelSegment:
 108                     segment = new NitfsLabelSegment(this.buffer, nextSegmentOffset, segHeaderLength,
 109                                         nextSegmentOffset + segHeaderLength, seqDataLength);
 110                     break;
 111                 case TextSegment:
 112                     segment = new NitfsTextSegment(this.buffer, nextSegmentOffset, segHeaderLength,
 113                                         nextSegmentOffset + segHeaderLength, seqDataLength);
 114                     break;
 115                 case DataExtensionSegment:
 116                     segment = new NitfsDataExtensionSegment(this.buffer, nextSegmentOffset, segHeaderLength,
 117                                         nextSegmentOffset + segHeaderLength, seqDataLength);
 118                     break;
 119                 case ReservedExtensionSegment:
 120                     segment = new NitfsReservedExtensionSegment(this.buffer, nextSegmentOffset, segHeaderLength,
 121                                         nextSegmentOffset + segHeaderLength, seqDataLength);
 122                     break;
 123                 case UserDefinedHeaderSegment:
 124                     segment = new RpfUserDefinedHeaderSegment(this.buffer);
 125                     break;
 126                 case ExtendedHeaderSegment:    // // throw exception - wrong parser for ExtendedHeaderSegment
 127                     segment = new NitfsExtendedHeaderSegment(this.buffer, nextSegmentOffset, segHeaderLength,
 128                                         nextSegmentOffset + segHeaderLength, seqDataLength);
 129                     break;
 130
 131                 default:
 132                     throw new NitfsRuntimeException("NitfsReader.UnknownOrUnsupportedSegment", segType.toString());
 133
 134             }
 135             this.segments.add(segment);
 136
 137             nextSegmentOffset += segHeaderLength + seqDataLength;
 138             buffer.position(saveOffset); // restore offset
 139         }
 140         return nextSegmentOffset;
 141     }
 142
 143     public static NitfsMessage load(java.io.File file) throws java.io.IOException
 144     {
 145         validateImageFile(file);
 146
 147         java.nio.ByteBuffer roBuffer = NitfsUtil.readEntireFile(file).asReadOnlyBuffer();
 148
 149         // check if it is a NITFS format file (NITF or NSIF - for NATO Secondary Imagery Format)
 150         String fmtId = NitfsUtil.getString(roBuffer, 0, 4);
 151         if( 0 != "NITF".compareTo(fmtId) && 0 != "NSIF".compareTo(fmtId))
 152         {
 153             roBuffer = null;
 154             throw new NitfsRuntimeException("NitfsReader.UnknownOrUnsupportedNitfsFormat", file.getCanonicalPath());
 155         }
 156
 157         return new NitfsMessage(roBuffer);
 158     }
 159
 160     private static void validateImageFile(java.io.File file)
 161         throws IOException, IllegalArgumentException, NitfsRuntimeException
 162     {
 163         if (null == file)
 164         {
 165             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 166             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 167             throw new IllegalArgumentException(message);
 168         }
 169         if (!file.exists() || !file.canRead())
 170             throw new NitfsRuntimeException("NitfsReader.NoFileOrNoPermission", file.getCanonicalPath());
 171     }
 172
 173     public static void main(String args[])
 174     {
 175         String testImageFilename = "/depot/WorldWindJ/utils/gdal/020g222a.i42";
 176
 177         if(Configuration.isWindowsOS())
 178             testImageFilename = "C:\\depot\\WorldWindJ\\utils\\gdal\\020g222a.i42";
 179
 180         try
 181         {
 182             long startTime = System.currentTimeMillis();
 183
 184             NitfsMessage img = NitfsMessage.load(new File(testImageFilename));
 185
 186             System.out.println(MessageFormat.format("Image loaded in {0} mSec", (System.currentTimeMillis() - startTime)));
 187
 188             System.out.println(img.fileHeader.getHeaderLength());
 189             System.out.println(img.fileHeader.getVersion());
 190             System.out.println(img.fileHeader.getComplexityLevel());
 191             System.out.println(img.fileHeader.getSpecialType());
 192             System.out.println(img.fileHeader.getOriginationStationId());
 193             System.out.println(img.fileHeader.getDateTime());
 194             System.out.println(img.fileHeader.getTitle());
 195             System.out.println(img.fileHeader.getFSCLAS());
 196
 197             System.out.println("HeaderLength=" + img.fileHeader.getHeaderLength());
 198             System.out.println("Total FileLength=" + img.fileHeader.getFileLength());
 199
 200             // System.out.println();
 201         }
 202         catch (Exception e)
 203         {
 204             System.out.println(e.getMessage());
 205             e.printStackTrace();
 206         }
 207     }
 208 }