Changeset 2289


Ignore:
Timestamp:
02/16/07 10:36:21 (13 years ago)
Author:
melissa
Message:

Fixed a subtle bug in metadata parsing.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/in/ZeissLSMReader.java

    r2288 r2289  
    2626 
    2727import java.awt.image.BufferedImage; 
    28 import java.io.IOException; 
     28import java.io.*; 
    2929import java.util.Hashtable; 
    3030import loci.formats.*; 
     
    158158 
    159159    // go through the IFD hashtable array and 
    160     // remove anything with NEw_SUBFILE_TYPE = 1 
     160    // remove anything with NEW_SUBFILE_TYPE = 1 
    161161    // NEW_SUBFILE_TYPE = 1 indicates that the IFD 
    162162    // contains a thumbnail image 
     
    233233    int idata = 0; 
    234234    double ddata = 0; 
    235     //short sdata = 0; 
     235    short sdata = 0; 
    236236 
    237237    try { 
    238       // -- Parse standard metadata -- 
    239  
    240       // determine byte order 
    241238      boolean little = TiffTools.isLittleEndian(ifd); 
    242239      in.order(little); 
     
    244241      super.initMetadata(); 
    245242 
    246       // get Zeiss LSM-specific data 
    247  
    248       // grab the TIF_CZ_LSMINFO structure, 512 bytes long 
    249       short[] cz = TiffTools.getIFDShortArray(ifd, ZEISS_ID, true); 
    250       int p = 0; // pointer to next byte in the structure 
    251  
    252       put("MagicNumber", DataTools.bytesToLong(cz, p, 4, little)); 
    253       p += 4; 
    254       put("StructureSize", DataTools.bytesToInt(cz, p, little)); 
    255       p += 4; 
    256       put("DimensionX", DataTools.bytesToInt(cz, p, little)); 
    257       p += 4; 
    258       put("DimensionY", DataTools.bytesToInt(cz, p, little)); 
    259       p += 4; 
    260       put("DimensionZ", DataTools.bytesToInt(cz, p, little)); 
    261       p += 4; 
    262       int dimensionChannels = DataTools.bytesToInt(cz, p, little); 
    263       put("DimensionChannels", dimensionChannels); 
    264       p += 4; 
    265       put("DimensionTime", DataTools.bytesToInt(cz, p, little)); 
    266       p += 4; 
    267  
    268       idata = DataTools.bytesToInt(cz, p, little); 
    269       String type; 
    270       switch (idata) { 
     243      // get TIF_CZ_LSMINFO structure 
     244      short[] s = TiffTools.getIFDShortArray(ifd, ZEISS_ID, true); 
     245      byte[] cz = new byte[s.length]; 
     246      for (int i=0; i<s.length; i++) { 
     247        cz[i] = (byte) s[i]; 
     248        if (cz[i] < 0) cz[i]++; // account for byte->short conversion 
     249      } 
     250 
     251      RandomAccessStream ras = new RandomAccessStream(cz); 
     252    
     253      put("MagicNumber", DataTools.read4UnsignedBytes(ras, little)); 
     254      put("StructureSize", DataTools.read4SignedBytes(ras, little)); 
     255      put("DimensionX", DataTools.read4SignedBytes(ras, little)); 
     256      put("DimensionY", DataTools.read4SignedBytes(ras, little)); 
     257 
     258      sizeZ[0] = DataTools.read4SignedBytes(ras, little); 
     259      sizeC[0] = DataTools.read4SignedBytes(ras, little); 
     260      sizeT[0] = DataTools.read4SignedBytes(ras, little); 
     261 
     262      if (sizeC[0] == 0) sizeC[0]++; 
     263 
     264      while (numImages > sizeZ[0] * sizeC[0] * sizeT[0]) { 
     265        if (sizeZ[0] > sizeT[0]) sizeZ[0]++; 
     266        else sizeT[0]++; 
     267      } 
     268 
     269      while (numImages > sizeZ[0] * sizeT[0] * getEffectiveSizeC(currentId)) { 
     270        numImages--; 
     271      } 
     272 
     273      put("DimensionZ", sizeZ[0]); 
     274      put("DimensionChannels", sizeC[0]); 
     275      put("DimensionTime", sizeT[0]); 
     276 
     277      int dataType = DataTools.read4SignedBytes(ras, little); 
     278      switch (dataType) { 
    271279        case 1: 
    272           type = "8 bit unsigned integer"; 
     280          put("DataType", "8 bit unsigned integer"); 
     281          pixelType[0] = FormatReader.UINT8; 
    273282          break; 
    274283        case 2: 
    275           type = "12 bit unsigned integer"; 
     284          put("DataType", "12 bit unsigned integer"); 
     285          pixelType[0] = FormatReader.UINT16; 
    276286          break; 
    277287        case 5: 
    278           type = "32 bit float"; 
     288          put("DataType", "32 bit float"); 
     289          pixelType[0] = FormatReader.FLOAT; 
    279290          break; 
    280291        case 0: 
    281           type = "varying data types"; 
     292          put("DataType", "varying data types"); 
     293          pixelType[0] = -1; 
    282294          break; 
    283295        default: 
    284           type = "8 bit unsigned integer"; 
    285       } 
    286       put("DataType", type); 
    287       p += 4; 
    288  
    289       put("ThumbnailX", DataTools.bytesToInt(cz, p, little)); 
    290       p += 4; 
    291       put("ThumbnailY", DataTools.bytesToInt(cz, p, little)); 
    292       p += 4; 
    293       put("VoxelSizeX", Double.longBitsToDouble( 
    294         DataTools.bytesToLong(cz, p, little))); 
    295       p += 8; 
    296       put("VoxelSizeY", Double.longBitsToDouble( 
    297         DataTools.bytesToLong(cz, p, little))); 
    298       p += 8; 
    299       put("VoxelSizeZ", Double.longBitsToDouble( 
    300         DataTools.bytesToLong(cz, p, little))); 
    301       p += 8 + 24; // skip over the next 24 bytes 
    302  
    303       idata = DataTools.bytesToInt(cz, p, 2, little); 
    304       switch (idata) { 
    305         case 0: 
    306           type = "x-y-z scan"; 
    307           break; 
    308         case 1: 
    309           type = "z scan (x-z plane)"; 
    310           break; 
    311         case 2: 
    312           type = "line scan"; 
    313           break; 
    314         case 3: 
    315           type = "time series x-y"; 
    316           break; 
    317         case 4: 
    318           type = "time series x-z"; 
    319           break; 
    320         case 5: 
    321           type = "time series 'Mean of ROIs'"; 
    322           break; 
    323         case 6: 
    324           type = "time series x-y-z"; 
    325           break; 
    326         case 7: 
    327           type = "spline scan"; 
    328           break; 
    329         case 8: 
    330           type = "spline scan x-z"; 
    331           break; 
    332         case 9: 
    333           type = "time series spline plane x-z"; 
    334           break; 
    335         case 10: 
    336           type = "point mode"; 
    337           break; 
    338         default: 
    339           type = "x-y-z scan"; 
    340       } 
    341       put("ScanType", type); 
    342       p += 2; 
    343  
    344       idata = DataTools.bytesToInt(cz, p, 2, little); 
    345       switch (idata) { 
    346         case 0: 
    347           type = "no spectral scan"; 
    348           break; 
    349         case 1: 
    350           type = "acquired with spectral scan"; 
    351           break; 
    352         default: 
    353           type = "no spectral scan"; 
    354       } 
    355       put("SpectralScan", type); 
    356       p += 2; 
    357  
    358       data = DataTools.bytesToLong(cz, p, 4, little); 
    359       switch ((int) data) { 
    360         case 0: 
    361           type = "original scan data"; 
    362           break; 
    363         case 1: 
    364           type = "calculated data"; 
    365           break; 
    366         case 2: 
    367           type = "animation"; 
    368           break; 
    369         default: 
    370           type = "original scan data"; 
    371       } 
    372       put("DataType2", type); 
    373       p += 4; 
    374  
    375       // -- Parse OME-XML metadata -- 
    376  
    377       short[] omeData = TiffTools.getIFDShortArray(ifd, ZEISS_ID, true); 
    378  
    379       int imageWidth = DataTools.bytesToInt(omeData, 8, little); 
    380       int imageLength = DataTools.bytesToInt(omeData, 12, little); 
    381       zSize = DataTools.bytesToInt(omeData, 16, little); 
    382       int cSize = DataTools.bytesToInt(omeData, 20, little); 
    383       tSize = DataTools.bytesToInt(omeData, 24, little); 
    384  
    385       int pixel = DataTools.bytesToInt(omeData, 28, little); 
    386       switch (pixel) { 
    387         case 1: 
    388           pixelType[0] = FormatReader.UINT8; 
    389           break; 
    390         case 2: 
    391           pixelType[0] = FormatReader.UINT16; 
    392           break; 
    393         case 5: 
    394           pixelType[0] = FormatReader.FLOAT; 
    395           break; 
    396         default: 
     296          put("DataType", "8 bit unsigned integer"); 
    397297          pixelType[0] = -1; 
    398298      } 
    399  
     299      
    400300      if (pixelType[0] == -1) { 
    401301        int[] bps = TiffTools.getBitsPerSample(ifd); 
     
    408308      } 
    409309 
    410       short scanType = DataTools.bytesToShort(omeData, 88, little); 
    411       switch ((int) scanType) { 
    412         case 0: 
    413           dimOrder = "XYZCT"; 
    414           break; 
    415         case 1: 
    416           dimOrder = "XYZCT"; 
    417           break; 
    418         case 3: 
    419           dimOrder = "XYTCZ"; 
    420           break; 
    421         case 4: 
    422           dimOrder = "XYZTC"; 
     310      put("ThumbnailX", DataTools.read4SignedBytes(ras, little)); 
     311      put("ThumbnailY", DataTools.read4SignedBytes(ras, little)); 
     312 
     313      put("VoxelSizeX", DataTools.readDouble(ras, little)); 
     314      put("VoxelSizeY", DataTools.readDouble(ras, little)); 
     315      put("VoxelSizeZ", DataTools.readDouble(ras, little)); 
     316       
     317      put("OriginX", DataTools.readDouble(ras, little)); 
     318      put("OriginY", DataTools.readDouble(ras, little)); 
     319      put("OriginZ", DataTools.readDouble(ras, little)); 
     320 
     321      int scanType = DataTools.read2UnsignedBytes(ras, little); 
     322      switch (scanType) { 
     323        case 0:  
     324          put("ScanType", "x-y-z scan");  
     325          currentOrder[0] = "XYZCT"; 
     326          break; 
     327        case 1:  
     328          put("ScanType", "z scan (x-z plane)");  
     329          currentOrder[0] = "XYZCT"; 
     330          break; 
     331        case 2:  
     332          put("ScanType", "line scan");  
     333          currentOrder[0] = "XYZCT"; 
     334          break; 
     335        case 3:  
     336          put("ScanType", "time series x-y");  
     337          currentOrder[0] = "XYTCZ"; 
     338          break; 
     339        case 4:  
     340          put("ScanType", "time series x-z");  
     341          currentOrder[0] = "XYZTC"; 
    423342          break; 
    424343        case 5: 
    425           dimOrder = "XYTCZ"; 
    426           break; 
    427         case 6: 
    428           dimOrder = "XYZTC"; 
    429           break; 
    430         case 7: 
    431           dimOrder = "XYCTZ"; 
    432           break; 
    433         case 8: 
    434           dimOrder = "XYCZT"; 
    435           break; 
    436         case 9: 
    437           dimOrder = "XYTCZ"; 
    438           break; 
    439         default: 
    440           dimOrder = "XYZCT"; 
    441       } 
    442  
    443       channels = cSize; 
    444  
    445       if (channels == 0) channels++; 
    446       //if (channels == 2) channels--; 
    447  
    448       while (numImages > zSize * channels * tSize) { 
    449         if (zSize > tSize) zSize++; 
    450         else tSize++; 
    451       } 
    452  
    453       sizeC[0] = channels; 
    454       sizeZ[0] = zSize; 
    455       sizeT[0] = tSize; 
    456       while (numImages > zSize * tSize * getEffectiveSizeC(currentId)) { 
    457         numImages--; 
    458       } 
    459  
    460       // The metadata store we're working with. 
     344          put("ScanType", "time series 'Mean of ROIs'");  
     345          currentOrder[0] = "XYTCZ"; 
     346          break; 
     347        case 6:  
     348          put("ScanType", "time series x-y-z");  
     349          currentOrder[0] = "XYZTC"; 
     350          break; 
     351        case 7:  
     352          put("ScanType", "spline scan");  
     353          currentOrder[0] = "XYCTZ"; 
     354          break; 
     355        case 8:  
     356          put("ScanType", "spline scan x-z");  
     357          currentOrder[0] = "XYCZT"; 
     358          break; 
     359        case 9:  
     360          put("ScanType", "time series spline plane x-z");  
     361          currentOrder[0] = "XYTCZ"; 
     362          break; 
     363        case 10:  
     364          put("ScanType", "point mode");  
     365          currentOrder[0] = "XYZCT"; 
     366          break; 
     367        default:  
     368          put("ScanType", "x-y-z scan"); 
     369          currentOrder[0] = "XYZCT"; 
     370      }  
     371      
    461372      MetadataStore store = getMetadataStore(currentId); 
    462373 
    463374      store.setPixels( 
    464         new Integer(imageWidth), // SizeX 
    465         new Integer(imageLength), // SizeY 
    466         new Integer(zSize), // SizeZ 
    467         new Integer(channels), // SizeC 
    468         new Integer(tSize), // SizeT 
     375        new Integer(sizeX[0]), // SizeX 
     376        new Integer(sizeY[0]), // SizeY 
     377        new Integer(sizeZ[0]), // SizeZ 
     378        new Integer(sizeC[0]), // SizeC 
     379        new Integer(sizeT[0]), // SizeT 
    469380        new Integer(pixelType[0]), // PixelType 
    470         null, // BigEndian 
    471         dimOrder, // DimensionOrder 
     381        new Boolean(!little), // BigEndian 
     382        currentOrder[0], // DimensionOrder 
    472383        null, // Image index 
    473384        null); // Pixels index 
    474385 
    475       int pos = in.getFilePointer(); 
    476  
    477       // the following 4 are file offsets 
    478       data = DataTools.bytesToLong(cz, p, 4, little); 
    479       parseOverlays(data, "OffsetVectorOverlay", little); 
    480       p += 4; 
    481       data = DataTools.bytesToLong(cz, p, 4, little); 
    482       parseSubBlocks(data, "OffsetInputLut", little); 
    483       p += 4; 
    484       data = DataTools.bytesToLong(cz, p, 4, little); 
    485       parseSubBlocks(data, "OffsetOutputLut", little); 
    486       p += 4; 
    487       data = DataTools.bytesToLong(cz, p, 4, little); 
    488       // seek to this offset and read in the structure there 
    489       // first we have to make sure that the structure actually exists 
    490  
    491       if (data != 0) { 
    492         pos = in.getFilePointer(); 
    493  
    494         in.seek(data + 4); 
    495         pos = in.getFilePointer() - 4; 
    496  
     386      int spectralScan = DataTools.read2UnsignedBytes(ras, little); 
     387      switch (spectralScan) { 
     388        case 0: put("SpectralScan", "no spectral scan"); break; 
     389        case 1: put("SpectralScan", "acquired with spectral scan"); break; 
     390        default: put("SpectralScan", "no spectral scan"); 
     391      } 
     392       
     393      long type = DataTools.read4UnsignedBytes(ras, little); 
     394      switch ((int) type) { 
     395        case 0: put("DataType2", "original scan data"); break; 
     396        case 1: put("DataType2", "calculated data"); break; 
     397        case 2: put("DataType2", "animation"); break; 
     398        default: put("DataType2", "original scan data"); 
     399      } 
     400       
     401      long overlayOffset = DataTools.read4UnsignedBytes(ras, little); 
     402      long inputLUTOffset = DataTools.read4UnsignedBytes(ras, little); 
     403      long outputLUTOffset = DataTools.read4UnsignedBytes(ras, little); 
     404      long channelColorsOffset = DataTools.read4UnsignedBytes(ras, little); 
     405 
     406      put("TimeInterval", DataTools.readDouble(ras, little)); 
     407 
     408      long channelDataTypesOffset = DataTools.read4UnsignedBytes(ras, little); 
     409      long scanInformationOffset = DataTools.read4UnsignedBytes(ras, little); 
     410      long ksDataOffset = DataTools.read4UnsignedBytes(ras, little); 
     411      long timeStampOffset = DataTools.read4UnsignedBytes(ras, little); 
     412      long eventListOffset = DataTools.read4UnsignedBytes(ras, little); 
     413      long roiOffset = DataTools.read4UnsignedBytes(ras, little); 
     414      long bleachRoiOffset = DataTools.read4UnsignedBytes(ras, little); 
     415      long nextRecordingOffset = DataTools.read4UnsignedBytes(ras, little); 
     416 
     417      put("DisplayAspectX", DataTools.readDouble(ras, little)); 
     418      put("DisplayAspectY", DataTools.readDouble(ras, little)); 
     419      put("DisplayAspectZ", DataTools.readDouble(ras, little)); 
     420      put("DisplayAspectTime", DataTools.readDouble(ras, little)); 
     421 
     422      long meanOfRoisOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
     423      long topoIsolineOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
     424      long topoProfileOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
     425      long linescanOverlayOffset = DataTools.read4UnsignedBytes(ras, little); 
     426       
     427      put("ToolbarFlags", DataTools.read4UnsignedBytes(ras, little)); 
     428      long channelWavelengthOffset = DataTools.read4UnsignedBytes(ras, little); 
     429      long channelFactorsOffset = DataTools.read4UnsignedBytes(ras, little); 
     430 
     431      double objectiveSphereCorrection = DataTools.readDouble(ras, little); 
     432      long unmixParamsOffset = DataTools.read4UnsignedBytes(ras, little); 
     433 
     434      // read referenced structures 
     435    
     436      if (overlayOffset != 0) { 
     437        parseOverlays(overlayOffset, "OffsetVectorOverlay", little); 
     438      } 
     439 
     440      if (inputLUTOffset != 0) { 
     441        parseSubBlocks(inputLUTOffset, "OffsetInputLut", little);  
     442      } 
     443 
     444      if (outputLUTOffset != 0) { 
     445        parseSubBlocks(outputLUTOffset, "OffsetOutputLut", little); 
     446      } 
     447 
     448      if (channelColorsOffset != 0) { 
     449        in.seek(channelColorsOffset + 4); 
    497450        int numColors = in.readInt(); 
    498451        int numNames = in.readInt(); 
    499452 
    500         if (numColors > getSizeC(currentId)) { 
    501           in.seek(data - 2); 
    502           pos = in.getFilePointer() + 7; 
    503           in.order(!in.isLittleEndian()); 
     453        if (numColors > sizeC[0]) { 
     454          in.seek(channelColorsOffset - 2); 
     455          in.order(!little); 
    504456          in.readInt(); 
    505457          numColors = in.readInt(); 
     
    507459        } 
    508460 
    509         idata = in.readInt(); 
     461        long namesOffset = in.readInt() + channelColorsOffset;  
    510462        int nameData = in.readInt(); 
    511         long offsetNames = pos + idata; // will seek to this 
    512463 
    513464        // read in the intensity value for each color 
    514465 
    515         if (offsetNames >= 0) { 
    516           in.seek(offsetNames); 
    517  
    518           for (int i=0; i<numColors; i++) { 
    519             data = in.readInt(); 
    520             put("Intensity" + i, data); 
     466        if (namesOffset >= 0) { 
     467          in.seek(namesOffset); 
     468          for (int i=0; i<numColors; i++) put("Intensity" + i, in.readInt()); 
     469        } 
     470 
     471        // read in the channel names 
     472   
     473        for (int i=0; i<numNames; i++) { 
     474          // we want to read until we find a null char 
     475          StringBuffer sb = new StringBuffer(); 
     476          char current = (char) in.read(); 
     477          while (current != 0) { 
     478            sb.append(current); 
     479            current = (char) in.read(); 
    521480          } 
    522  
    523           // read in the channel names 
    524    
    525           for (int i=0; i<numNames; i++) { 
    526             // we want to read until we find a null char 
    527             StringBuffer sb = new StringBuffer(); 
    528             char current = (char) in.read(); 
    529             while (current != 0) { 
    530               sb.append(current); 
    531               current = (char) in.read(); 
    532             } 
    533             String name = sb.toString(); 
    534             put("ChannelName" + i, name); 
    535           } 
    536         } 
    537         in.seek(pos); 
    538         in.order(isLittleEndian(currentId)); 
    539       } 
    540       p += 4; 
    541  
    542       put("TimeInterval", Double.longBitsToDouble( 
    543         DataTools.bytesToLong(cz, p, little))); 
    544       p += 8; 
    545  
    546       // the following 8 are file offsets 
    547  
    548       data = DataTools.bytesToLong(cz, p, 4, little); 
    549       if (data != 0) { 
    550         in.skipBytes((int) data); 
    551  
    552         for (int i=0; i<dimensionChannels; i++) { 
    553           put("OffsetChannelDataTypes" + i, in.readInt()); 
    554         } 
    555         in.seek(pos); 
    556       } 
    557       p += 4; 
    558  
    559       put("OffsetScanInformation", DataTools.bytesToLong(cz, p, 4, little)); 
    560       p += 4; 
    561  
    562       put("OffsetKsData", DataTools.bytesToLong(cz, p, 4, little)); 
    563       p += 4; 
    564  
    565       data = DataTools.bytesToLong(cz, p, 4, little); 
    566       if (data != 0) { 
    567         pos = in.getFilePointer(); 
    568         in.skipBytes((int) data + 4); 
    569  
    570         int numStamps = in.readInt(); 
    571         if (numStamps > 1000) numStamps = 1000; 
    572         for (int i=0; i<numStamps; i++) { 
    573           ddata = in.readDouble(); 
    574           put("TimeStamp" + i, ddata); 
    575         } 
    576         in.seek(pos); 
    577       } 
    578       p += 4; 
    579  
    580       data = DataTools.bytesToLong(cz, p, 4, little); 
    581       if (data != 0) { 
    582         pos = in.getFilePointer(); 
    583  
    584         long numBytes = in.readInt(); 
     481          put("ChannelName" + i, sb.toString()); 
     482        } 
     483      } 
     484 
     485      if (timeStampOffset != 0) { 
     486        in.seek(timeStampOffset); 
     487        int blockSize = DataTools.read4SignedBytes(in, little); 
     488        int numberOfStamps = DataTools.read4SignedBytes(in, little); 
     489        for (int i=0; i<numberOfStamps; i++) { 
     490          put("TimeStamp" + i, DataTools.readDouble(in, little)); 
     491        } 
     492      } 
     493 
     494      if (eventListOffset != 0) { 
     495        in.seek(eventListOffset); 
     496        in.skipBytes(4); // skipping the block size 
    585497        int numEvents = in.readInt(); 
    586         in.seek((int) (pos + data + 8)); 
    587  
    588         if (numEvents <= numImages) { 
    589           for (int i=0; i<numEvents; i++) { 
    590             in.readInt(); 
    591             ddata = in.readDouble(); 
    592             put("Time" + i, ddata); 
    593  
    594             data = in.readInt(); 
    595             put("EventType" + i, data); 
    596  
    597             if (numBytes > in.length() - in.getFilePointer()) { 
    598               numBytes = in.length() - in.getFilePointer(); 
    599             } 
    600             if (numBytes < 16) numBytes = 16; 
    601             byte[] descr = new byte[(int) (numBytes - 16)]; 
    602             in.read(descr); 
    603             put("Description" + i, new String(descr)); 
    604           } 
    605         } 
    606         in.seek(pos); 
    607       } 
    608       p += 4; 
    609  
    610       data = DataTools.bytesToLong(cz, p, 4, little); 
    611       parseOverlays(data, "OffsetRoi", little); 
    612       p += 4; 
    613       data = DataTools.bytesToLong(cz, p, 4, little); 
    614       parseOverlays(data, "OffsetBleachRoi", little); 
    615       p += 4; 
    616       put("OffsetNextRecording", DataTools.bytesToLong(cz, p, 4, little)); 
    617       p += 4; 
    618  
    619       put("DisplayAspectX", Double.longBitsToDouble( 
    620         DataTools.bytesToLong(cz, p, little))); 
    621       p += 8; 
    622       put("DisplayAspectY", Double.longBitsToDouble( 
    623         DataTools.bytesToLong(cz, p, little))); 
    624       p += 8; 
    625       put("DisplayAspectZ", Double.longBitsToDouble( 
    626         DataTools.bytesToLong(cz, p, little))); 
    627       p += 8; 
    628       put("DisplayAspectTime", Double.longBitsToDouble( 
    629         DataTools.bytesToLong(cz, p, little))); 
    630       p += 8; 
    631  
    632       // the following 4 are file offsets 
    633       data = DataTools.bytesToLong(cz, p, 4, little); 
    634       parseOverlays(data, "OffsetMeanOfRoisOverlay", little); 
    635       p += 4; 
    636       data = DataTools.bytesToLong(cz, p, 4, little); 
    637       parseOverlays(data, "OffsetTopoIsolineOverlay", little); 
    638       p += 4; 
    639       data = DataTools.bytesToLong(cz, p, 4, little); 
    640       parseOverlays(data, "OffsetTopoProfileOverlay", little); 
    641       p += 4; 
    642       data = DataTools.bytesToLong(cz, p, 4, little); 
    643       parseOverlays(data, "OffsetLinescanOverlay", little); 
    644       p += 4; 
    645  
    646       put("ToolbarFlags", DataTools.bytesToLong(cz, p, 4, little)); 
    647  
    648       // the following 2 are file offsets 
    649       put("OffsetChannelWavelength", DataTools.bytesToLong(cz, p, 4, little)); 
    650       p += 4; 
    651       put("OffsetChannelFactors", DataTools.bytesToLong(cz, p, 4, little)); 
    652       p += 4; 
    653  
    654       put("ObjectiveSphereCorrection", Double.longBitsToDouble( 
    655         DataTools.bytesToLong(cz, p, little))); 
    656       p += 8; 
    657  
    658       // the following is a file offset 
    659       put("OffsetUnmixParameters", DataTools.bytesToLong(cz, p, 4, little)); 
    660       p += 4; 
    661  
    662       in.seek(pos); 
     498        for (int i=0; i<numEvents; i++) { 
     499          int size = in.readInt(); 
     500          double eventTime = in.readDouble(); 
     501          int eventType = in.readInt(); 
     502          byte[] b = new byte[size - 16]; 
     503          in.read(b); 
     504          put("Event" + i + " Time", eventTime); 
     505          put("Event" + i + " Type", eventType); 
     506          put("Event" + i + " Description", new String(b)); 
     507        } 
     508      } 
     509 
     510      if (roiOffset != 0) parseOverlays(roiOffset, "ROIOffset", little); 
     511 
     512      if (bleachRoiOffset != 0) { 
     513        parseOverlays(bleachRoiOffset, "BleachROIOffset", little); 
     514      } 
     515 
     516      if (meanOfRoisOverlayOffset != 0) { 
     517        parseOverlays(meanOfRoisOverlayOffset,  
     518          "OffsetMeanOfRoisOverlay", little); 
     519      } 
     520 
     521      if (topoIsolineOverlayOffset != 0) { 
     522        parseOverlays(topoIsolineOverlayOffset,  
     523          "OffsetTopoIsolineOverlay", little); 
     524      } 
     525 
     526      if (topoProfileOverlayOffset != 0) { 
     527        parseOverlays(topoProfileOverlayOffset,  
     528          "OffsetTopoProfileOverlay", little); 
     529      } 
     530 
     531      if (linescanOverlayOffset != 0) { 
     532        parseOverlays(linescanOverlayOffset, "OffsetLinescanOverlay", little); 
     533      } 
    663534    } 
    664535    catch (FormatException e) { 
     
    668539      if (debug) e.printStackTrace(); 
    669540    } 
    670  
    671     sizeZ[0] = zSize > 0 ? zSize : 1; 
    672     sizeC[0] = channels > 0 ? channels : 1; 
    673     sizeT[0] = tSize > 0 ? tSize : 1; 
    674     currentOrder[0] = "XYZCT"; 
    675541 
    676542    Object pixelSizeX = getMeta("VoxelSizeX"); 
Note: See TracChangeset for help on using the changeset viewer.