Changeset 2964


Ignore:
Timestamp:
07/11/07 12:16:51 (13 years ago)
Author:
melissa
Message:
  • Removed unnecessary imports from TiffReader.
  • Cleaned up ZVI reader (and fixed several issues)
Location:
trunk/loci/formats/in
Files:
2 edited

Legend:

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

    r2943 r2964  
    2525package loci.formats.in; 
    2626 
    27 import java.io.ByteArrayInputStream; 
    2827import java.io.IOException; 
    2928import java.util.*; 
    30 import javax.xml.parsers.*; 
    3129import loci.formats.*; 
    32 import org.w3c.dom.*; 
    33 import org.xml.sax.SAXException; 
    3430 
    3531/** 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r2857 r2964  
    302302          "XY" + axes[maxNdx] + axes[medNdx] + axes[minNdx]; 
    303303 
    304         if (zIndex != -1 && tIndex != -1) { 
     304        int num = core.sizeZ[0] * core.sizeT[0] - core.sizeC[0]; 
     305        if ((zIndex != -1 && tIndex != -1) && (zIndex != num && tIndex != num)) 
     306        { 
    305307          if (zIndex != core.sizeZ[0]) { 
    306308            if (core.sizeZ[0] != 1) { 
     
    325327      } 
    326328      else { 
    327         core.currentOrder[0] = 
    328           (core.sizeZ[0] > core.sizeT[0]) ? "XYZTC" : "XYTZC"; 
     329        if (metadata.get("MultiChannelEnabled") != null) { 
     330          core.currentOrder[0] = 
     331            (core.sizeZ[0] > core.sizeT[0]) ? "XYCZT" : "XYCTZ"; 
     332        } 
     333        else { 
     334          core.currentOrder[0] = 
     335            (core.sizeZ[0] > core.sizeT[0]) ? "XYZTC" : "XYTZC"; 
     336        } 
    329337      } 
    330338    } 
     
    433441        Object directory = r.getVar("dir"); 
    434442 
    435         int pt = 0; 
     443        RandomAccessStream s = new RandomAccessStream(data); 
     444        s.order(true); 
    436445 
    437446        if (dirName.toUpperCase().equals("ROOT ENTRY") || 
     
    439448        { 
    440449          if (entryName.equals("Tags")) { 
    441             pt += 18; 
    442             int version = DataTools.bytesToInt(data, pt, 4, true); 
    443             pt += 4; 
    444  
    445             pt += 2; 
    446             int count = DataTools.bytesToInt(data, pt, 4, true); // # of tags 
    447             pt += 4; 
    448  
    449             // limit count to 4096 
    450             if (count > 4096) count = 4096; 
    451  
    452             for (int i=0; i<count; i++) { 
    453               int type = DataTools.bytesToInt(data, pt, 2, true); 
    454               pt += 2; 
    455  
    456               String value = ""; 
    457               switch (type) { 
    458                 case 0: 
    459                   break; 
    460                 case 1: 
    461                   break; 
    462                 case 2: 
    463                   value = "" + DataTools.bytesToInt(data, pt, 2, true); 
    464                   pt += 2; 
    465                   break; 
    466                 case 3: 
    467                   value = "" + DataTools.bytesToInt(data, pt, 4, true); 
    468                   pt += 4; 
    469                   break; 
    470                 case 4: 
    471                   value = "" + Float.intBitsToFloat( 
    472                     DataTools.bytesToInt(data, pt, 4, true)); 
    473                   pt += 4; 
    474                   break; 
    475                 case 5: 
    476                   value = "" + Double.longBitsToDouble( 
    477                     DataTools.bytesToLong(data, pt, 8, true)); 
    478                   pt += 8; 
    479                   break; 
    480                 case 7: 
    481                   value = "" + DataTools.bytesToLong(data, pt, 8, true); 
    482                   pt += 8; 
    483                   break; 
    484                 case 69: 
    485                 case 8: 
    486                   int len = DataTools.bytesToInt(data, pt, 4, true); 
    487                   pt += 4; 
    488                   value = new String(data, pt, len); 
    489                   pt += len; 
    490                   break; 
    491                 case 20: 
    492                 case 21: 
    493                   value = "" + DataTools.bytesToLong(data, pt, 8, true); 
    494                   pt += 8; 
    495                   break; 
    496                 case 22: 
    497                 case 23: 
    498                   value = "" + DataTools.bytesToInt(data, pt, 4, true); 
    499                   pt += 4; 
    500                   break; 
    501                 case 66: 
    502                   int l = DataTools.bytesToInt(data, pt, 2, true); 
    503                   pt += 2; 
    504                   value = new String(data, pt - 2, l + 2); 
    505                   pt += l; 
    506                   break; 
    507                 default: 
    508                   int oldPt = pt; 
    509                   while (DataTools.bytesToInt(data, pt, 2, true) != 3 && 
    510                     pt < data.length) 
    511                   { 
    512                     pt += 2; 
    513                   } 
    514                   value = new String(data, oldPt - 2, pt - oldPt + 2); 
    515               } 
    516  
    517               pt += 2; 
    518               int tagID = DataTools.bytesToInt(data, pt, 4, true); 
    519               pt += 4; 
    520               pt += 2; 
    521               int attribute = DataTools.bytesToInt(data, pt, 4, true); 
    522               pt += 4; 
    523               parseTag(value, tagID, attribute); 
    524             } 
     450            parseTags(s);  
    525451          } 
    526452        } 
    527453        else if (dirName.equals("Tags") && isContents) { 
    528           pt += 18; 
    529           int version = DataTools.bytesToInt(data, pt, 4, true); 
    530           pt += 4; 
    531  
    532           pt += 2; 
    533           int count = DataTools.bytesToInt(data, pt, 4, true); // # of tags 
    534           pt += 4; 
    535  
    536           // limit count to 4096 
    537           if (count > 4096) count = 4096; 
    538  
    539           for (int i=0; i<count; i++) { 
    540             int type = DataTools.bytesToInt(data, pt, 2, true); 
    541             pt += 2; 
    542  
    543             String value = ""; 
    544             switch (type) { 
    545               case 0: 
    546                 break; 
    547               case 1: 
    548                 break; 
    549               case 2: 
    550                 value = "" + DataTools.bytesToInt(data, pt, 2, true); 
    551                 pt += 2; 
    552                 break; 
    553               case 3: 
    554                 value = "" + DataTools.bytesToInt(data, pt, 4, true); 
    555                 pt += 4; 
    556                 break; 
    557               case 4: 
    558                 value = "" + Float.intBitsToFloat( 
    559                   DataTools.bytesToInt(data, pt, 4, true)); 
    560                 pt += 4; 
    561                 break; 
    562               case 5: 
    563                 value = "" + Double.longBitsToDouble( 
    564                   DataTools.bytesToLong(data, pt, 8, true)); 
    565                 pt += 8; 
    566                 break; 
    567               case 7: 
    568                 value = "" + DataTools.bytesToLong(data, pt, 8, true); 
    569                 pt += 8; 
    570                 break; 
    571               case 69: 
    572               case 8: 
    573                 int len = DataTools.bytesToInt(data, pt, 4, true); 
    574                 pt += 4; 
    575                 if (pt + len < data.length) { 
    576                   value = new String(data, pt, len); 
    577                   pt += len; 
    578                 } 
    579                 else return; 
    580                 break; 
    581               case 20: 
    582               case 21: 
    583                 value = "" + DataTools.bytesToLong(data, pt, 8, true); 
    584                 pt += 8; 
    585                 break; 
    586               case 22: 
    587               case 23: 
    588                 value = "" + DataTools.bytesToInt(data, pt, 4, true); 
    589                 pt += 4; 
    590                 break; 
    591               case 66: 
    592                 int l = DataTools.bytesToInt(data, pt, 2, true); 
    593                 pt += 2; 
    594                 value = new String(data, pt - 2, l + 2); 
    595                 pt += l; 
    596                 break; 
    597               default: 
    598                 int oldPt = pt; 
    599                 while (DataTools.bytesToInt(data, pt, 2, true) != 3 && 
    600                   pt < data.length) 
    601                 { 
    602                   pt += 2; 
    603                 } 
    604                 if (oldPt - 2 > 0 && pt < data.length) { 
    605                   value = new String(data, oldPt - 2, pt - oldPt + 2); 
    606                 } 
    607                 else return; 
    608             } 
    609  
    610             pt += 2; 
    611             int tagID = DataTools.bytesToInt(data, pt, 4, true); 
    612             pt += 4; 
    613             pt += 2; 
    614             int attribute = DataTools.bytesToInt(data, pt, 4, true); 
    615             pt += 4; 
    616             parseTag(value, tagID, attribute); 
    617           } 
     454          parseTags(s);  
    618455        } 
    619456        else if (isContents && (dirName.equals("Image") || 
     
    621458          (data.length > core.sizeX[0]*core.sizeY[0])) 
    622459        { 
    623           pt += 2; 
    624           int version = DataTools.bytesToInt(data, pt, 4, true); 
    625           pt += 4; 
    626  
    627           int vt = DataTools.bytesToInt(data, pt, 2, true); 
    628           pt += 2; 
     460          s.skipBytes(6);  
     461 
     462          int vt = s.readShort(); 
    629463          if (vt == 3) { 
    630             int type = DataTools.bytesToInt(data, pt, 4, true); 
    631             pt += 6; 
     464            s.skipBytes(6);  
    632465          } 
    633466          else if (vt == 8) { 
    634             int l = DataTools.bytesToInt(data, pt, 2, true); 
    635             pt += 4 + l; 
     467            int l = s.readShort();  
     468            s.skipBytes(l + 2);  
    636469          } 
    637           int len = DataTools.bytesToInt(data, pt, 2, true); 
    638           pt += 2; 
    639           if (data[pt] == 0 && data[pt + 1] == 0) pt += 2; 
     470          int len = s.readShort();  
     471          if (s.readShort() != 0) s.seek(s.getFilePointer() - 2);  
    640472 
    641473          String typeDescription = ""; 
    642           if (pt + len <= data.length) { 
    643             typeDescription = new String(data, pt, len); 
    644             pt += len; 
     474          if (s.getFilePointer() + len <= s.length()) { 
     475            typeDescription = s.readString(len); 
    645476          } 
    646477          else break; 
    647478 
    648           vt = DataTools.bytesToInt(data, pt, 2, true); 
    649           pt += 2; 
     479          vt = s.readShort(); 
    650480          if (vt == 8) { 
    651             len = DataTools.bytesToInt(data, pt, 4, true); 
    652             pt += 6 + len; 
     481            len = s.readInt();  
     482            s.skipBytes(len + 2);  
    653483          } 
    654484 
    655           int tw = DataTools.bytesToInt(data, pt, 4, true); 
     485          int tw = s.readInt(); 
    656486          if (core.sizeX[0] == 0 || (tw < core.sizeX[0] && tw > 0)) { 
    657487            core.sizeX[0] = tw; 
    658488          } 
    659           pt += 6; 
    660           int th = DataTools.bytesToInt(data, pt, 4, true); 
     489          s.skipBytes(2);  
     490          int th = s.readInt();  
    661491          if (core.sizeY[0] == 0 || (th < core.sizeY[0] && th > 0)) { 
    662492            core.sizeY[0] = th; 
    663493          } 
    664           pt += 6; 
    665  
    666           int zDepth = DataTools.bytesToInt(data, pt, 4, true); 
    667           pt += 6; 
    668           int pixelFormat = DataTools.bytesToInt(data, pt, 4, true); 
    669           pt += 6; 
    670           int numImageContainers = DataTools.bytesToInt(data, pt, 4, true); 
    671           pt += 6; 
    672           int validBitsPerPixel = DataTools.bytesToInt(data, pt, 4, true); 
    673           pt += 4; 
     494          s.skipBytes(2); 
     495 
     496          int zDepth = s.readInt(); 
     497          s.skipBytes(2); 
     498          int pixelFormat = s.readInt(); 
     499          s.skipBytes(2); 
     500          int numImageContainers = s.readInt(); 
     501          s.skipBytes(2); 
     502          int validBitsPerPixel = s.readInt(); 
    674503 
    675504          // VT_CLSID - PluginCLSID 
    676           while (DataTools.bytesToInt(data, pt, 2, true) != 65) { 
    677             pt += 2; 
    678           } 
     505          while (s.readShort() != 65); 
    679506 
    680507          // VT_BLOB - Others 
    681           pt += 2; 
    682           len = DataTools.bytesToInt(data, pt, 4, true); 
    683           pt += len + 4; 
     508          len = s.readInt();  
     509          s.skipBytes(len);  
    684510 
    685511          // VT_STORED_OBJECT - Layers 
    686           pt += 2; 
    687           int oldPt = pt; 
    688           len = DataTools.bytesToInt(data, pt, 4, true); 
    689           pt += 4; 
    690  
    691           pt += 8; 
    692  
    693           int tidx = DataTools.bytesToInt(data, pt, 4, true); 
    694           pt += 4; 
    695           int cidx = DataTools.bytesToInt(data, pt, 4, true); 
    696           pt += 4; 
    697           int zidx = DataTools.bytesToInt(data, pt, 4, true); 
    698           pt += 4; 
     512          s.skipBytes(2); 
     513          long old = s.getFilePointer(); 
     514          len = s.readInt();  
     515 
     516          s.skipBytes(8); 
     517 
     518          int tidx = s.readInt(); 
     519          int cidx = s.readInt();  
     520          int zidx = s.readInt();  
    699521 
    700522          Integer zndx = new Integer(zidx); 
     
    706528          if (!tIndices.contains(tndx)) tIndices.add(tndx); 
    707529 
    708           pt = oldPt + 4 + len; 
    709  
    710           boolean foundWidth = 
    711             DataTools.bytesToInt(data, pt, 4, true) == core.sizeX[0]; 
    712           boolean foundHeight = 
    713             DataTools.bytesToInt(data, pt + 4, 4, true) == core.sizeY[0]; 
     530          s.seek(old + len + 4); 
     531 
     532          boolean foundWidth = s.readInt() == core.sizeX[0]; 
     533          boolean foundHeight = s.readInt() == core.sizeY[0];  
    714534          boolean findFailed = false; 
    715           while ((!foundWidth || !foundHeight) && pt + 9 < data.length) { 
    716             pt++; 
    717             foundWidth = 
    718               DataTools.bytesToInt(data, pt, 4, true) == core.sizeX[0]; 
    719             foundHeight = 
    720               DataTools.bytesToInt(data, pt + 4, 4, true) == core.sizeY[0]; 
     535          while ((!foundWidth || !foundHeight) &&  
     536            s.getFilePointer() + 1 < s.length())  
     537          { 
     538            s.seek(s.getFilePointer() - 7);  
     539            foundWidth = s.readInt() == core.sizeX[0];  
     540            foundHeight = s.readInt() == core.sizeY[0];  
    721541          } 
    722           pt -= 8; 
     542          s.seek(s.getFilePointer() - 16);  
    723543          findFailed = !foundWidth && !foundHeight; 
    724544 
     
    728548            (dirName.equals("Image") && numImageContainers == 0)) 
    729549          { 
    730             if (findFailed) pt = oldPt + 4 + len + 88; 
    731             byte[] o = new byte[data.length - pt]; 
    732             System.arraycopy(data, pt, o, 0, o.length); 
     550            if (findFailed) s.seek(old + len + 92); 
     551            long fp = s.getFilePointer(); 
     552            byte[] o = new byte[(int) (s.length() - fp)]; 
     553            s.read(o); 
    733554 
    734555            int imageNum = 0; 
     
    739560            } 
    740561 
    741             offsets.put(new Integer(imageNum), new Integer(pt + 32)); 
     562            offsets.put(new Integer(imageNum), new Integer((int) fp + 32)); 
    742563            parsePlane(o, imageNum, directory, entryName); 
    743564          } 
    744565        } 
    745  
     566        s.close(); 
    746567        data = null; 
    747568        r.exec("dis.close()"); 
     
    760581  /** Parse a plane of data. */ 
    761582  private void parsePlane(byte[] data, int num, Object directory, String entry) 
     583    throws IOException  
    762584  { 
    763     int pt = 2; 
    764  
    765     int version = DataTools.bytesToInt(data, pt, 4, true); 
    766     pt += 6; 
    767     core.sizeX[0] = DataTools.bytesToInt(data, pt, 4, true); 
    768     pt += 4; 
    769     core.sizeY[0] = DataTools.bytesToInt(data, pt, 4, true); 
    770     pt += 4; 
    771     int depth = DataTools.bytesToInt(data, pt, 4, true); // z depth 
    772     pt += 4; 
    773     bpp = DataTools.bytesToInt(data, pt, 4, true); 
    774     pt += 4; 
    775     int pixelFormat = DataTools.bytesToInt(data, pt, 4, true); // ignore here 
    776     pt += 4; 
    777     int validBitsPerPixel = DataTools.bytesToInt(data, pt, 4, true); 
    778     pt += 4; 
     585    RandomAccessStream s = new RandomAccessStream(data); 
     586    s.order(true); 
     587    s.skipBytes(8); 
     588     
     589    core.sizeX[0] = s.readInt();  
     590    core.sizeY[0] = s.readInt();  
     591    int depth = s.readInt();  
     592    bpp = s.readInt();  
     593    int pixelFormat = s.readInt();  
     594    int validBitsPerPixel = s.readInt();  
    779595 
    780596    pixels.put(new Integer(num), directory); 
     
    785601  } 
    786602 
     603  /** Parse all of the tags in a stream. */ 
     604  private void parseTags(RandomAccessStream s) throws IOException { 
     605    s.skipBytes(24);  
     606 
     607    int count = s.readInt();  
     608 
     609    // limit count to 4096 
     610    if (count > 4096) count = 4096; 
     611 
     612    for (int i=0; i<count; i++) { 
     613      if (s.getFilePointer() + 2 >= s.length()) break;  
     614      int type = s.readShort();  
     615 
     616      String value = ""; 
     617      switch (type) { 
     618        case 0: 
     619          break; 
     620        case 1: 
     621          break; 
     622        case 2: 
     623          value = "" + s.readShort();  
     624          break; 
     625        case 3: 
     626        case 22: 
     627        case 23: 
     628          value = "" + s.readInt();  
     629          break; 
     630        case 4: 
     631          value = "" + s.readFloat();  
     632          break; 
     633        case 5: 
     634          value = "" + s.readDouble();  
     635          break; 
     636        case 7: 
     637        case 20: 
     638        case 21: 
     639          value = "" + s.readLong();  
     640          break; 
     641        case 69: 
     642        case 8: 
     643          int len = s.readInt(); 
     644          if (s.getFilePointer() + len < s.length()) { 
     645            value = s.readString(len); 
     646          } 
     647          else return;  
     648          break; 
     649        case 66: 
     650          int l = s.readShort();  
     651          s.seek(s.getFilePointer() - 2); 
     652          value = s.readString(l + 2); 
     653          break; 
     654        default: 
     655          long old = s.getFilePointer();  
     656          while (s.readShort() != 3 &&  
     657            s.getFilePointer() + 2 < s.length()); 
     658          long fp = s.getFilePointer() - 2;  
     659          s.seek(old - 2); 
     660          value = s.readString((int) (fp - old + 2)); 
     661      } 
     662   
     663      s.skipBytes(2);  
     664      int tagID = 0; 
     665      int attribute = 0;  
     666     
     667      try { tagID = s.readInt(); } 
     668      catch (IOException e) { } 
     669    
     670      s.skipBytes(2);  
     671    
     672      try { attribute = s.readInt(); } 
     673      catch (IOException e) { } 
     674      
     675      parseTag(value, tagID, attribute); 
     676      if (metadata.get("ImageWidth") != null) { 
     677        try {  
     678          if (core.sizeX[0] == 0) core.sizeX[0] = Integer.parseInt(value);  
     679        } 
     680        catch (NumberFormatException e) { } 
     681      }  
     682      if (metadata.get("ImageHeight") != null) { 
     683        try {  
     684          if (core.sizeY[0] == 0) core.sizeY[0] = Integer.parseInt(value);  
     685        } 
     686        catch (NumberFormatException e) { } 
     687      }  
     688    } 
     689  } 
     690 
    787691  /** Parse a tag and place it in the metadata hashtable. */ 
    788692  private void parseTag(String data, int tagID, int attribute) { 
Note: See TracChangeset for help on using the changeset viewer.