Changeset 3444


Ignore:
Timestamp:
12/04/07 12:39:12 (12 years ago)
Author:
melissa
Message:

Added logic to handle multiple series in a group of files; patterns such as

Series000_Z<0-4>.tif
Series001_Z<0-2>.tif
Series002_Z<0-7>.tif

are now detected as a 3-series dataset, instead of a single-series dataset with Z=3 and T=3.

Location:
trunk/loci/formats
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/AxisGuesser.java

    r3135 r3444  
    5555  public static final int C_AXIS = 3; 
    5656 
     57  /** Axis type for series. */ 
     58  public static final int S_AXIS = 4; 
     59 
    5760  /** Prefix endings indicating space dimension. */ 
    5861  protected static final String[] Z = { 
     
    6568  /** Prefix endings indicating channel dimension. */ 
    6669  protected static final String[] C = {"c", "ch", "w", "wavelength"}; 
     70 
     71  /** Prefix endings indicating series dimension. */ 
     72  protected static final String[] S = {"s", "series"}; 
    6773 
    6874  protected static final BigInteger TWO = new BigInteger("2"); 
     
    117123    int[] count = fp.getCount(); 
    118124    axisTypes = new int[count.length]; 
    119     boolean foundZ = false, foundT = false, foundC = false; 
     125    boolean foundZ = false, foundT = false, foundC = false, foundS = false; 
    120126 
    121127    // -- 1) fill in "known" axes based on known patterns and conventions -- 
     
    163169          axisTypes[i] = C_AXIS; 
    164170          foundC = true; 
     171          break; 
     172        } 
     173      } 
     174      if (axisTypes[i] != UNKNOWN_AXIS) continue; 
     175 
     176      // check against known series prefixes 
     177      for (int j=0; j<S.length; j++) { 
     178        if (p.equals(S[j])) { 
     179          axisTypes[i] = S_AXIS; 
     180          foundS = true; 
    165181          break; 
    166182        } 
     
    241257   *     <li>T_AXIS: time points</li> 
    242258   *     <li>C_AXIS: channels</li> 
     259   *     <li>S_AXIS: series</li> 
    243260   *   </ul> 
    244261   */ 
     
    252269   *     <li>T_AXIS: time points</li> 
    253270   *     <li>C_AXIS: channels</li> 
     271   *     <li>S_AXIS: series</li> 
    254272   *   </ul> 
    255273   */ 
     
    264282  /** Gets the number of C axes in the pattern. */ 
    265283  public int getAxisCountC() { return getAxisCount(C_AXIS); } 
     284 
     285  /** Gets the number of S axes in the pattern. */ 
     286  public int getAxisCountS() { return getAxisCount(S_AXIS); } 
    266287 
    267288  /** Gets the number of axes in the pattern of the given type. 
     
    271292   *     <li>T_AXIS: time points</li> 
    272293   *     <li>C_AXIS: channels</li> 
     294   *     <li>S_AXIS: series</li> 
    273295   *   </ul> 
    274296   */ 
  • trunk/loci/formats/FileStitcher.java

    r3395 r3444  
    2828import java.io.*; 
    2929import java.lang.reflect.InvocationTargetException; 
     30import java.math.BigInteger; 
    3031import java.util.*; 
    3132 
     
    6162 
    6263  /** The matching files. */ 
    63   private String[] files; 
     64  private String[][] files; 
    6465 
    6566  /** Used files list. */ 
     
    6768 
    6869  /** Reader used for each file. */ 
    69   private IFormatReader[] readers; 
     70  private IFormatReader[][] readers; 
    7071 
    7172  /** Blank buffered image, for use when image counts vary between files. */ 
     
    9293  /** Core metadata. */ 
    9394  private CoreMetadata core; 
     95 
     96  /** Current series number. */ 
     97  private int series; 
    9498 
    9599  // -- Constructors -- 
     
    136140   *     <li>AxisGuesser.T_AXIS: time points</li> 
    137141   *     <li>AxisGuesser.C_AXIS: channels</li> 
     142   *     <li>AxisGuesser.S_AXIS: series</li> 
    138143   *   </ul> 
    139144   */ 
     
    150155   *     <li>AxisGuesser.T_AXIS: time points</li> 
    151156   *     <li>AxisGuesser.C_AXIS: channels</li> 
     157   *     <li>AxisGuesser.S_AXIS: series</li> 
    152158   *   </ul> 
    153159   */ 
     
    363369    FormatTools.assertId(currentId, true, 2); 
    364370    int[] q = computeIndices(no); 
     371    int sno = getSeries(); 
    365372    int fno = q[0], ino = q[1]; 
    366     if (ino < readers[fno].getImageCount()) { 
    367       return readers[fno].openImage(ino); 
     373    if (ino < readers[sno][fno].getImageCount()) { 
     374      return readers[sno][fno].openImage(ino); 
    368375    } 
    369376 
    370377    // return a blank image to cover for the fact that 
    371378    // this file does not contain enough image planes 
    372     int sno = getSeries(); 
    373379    if (blankImage[sno] == null) { 
    374380      blankImage[sno] = ImageTools.blankImage(core.sizeX[sno], core.sizeY[sno], 
     
    390396    FormatTools.assertId(currentId, true, 2); 
    391397    int[] q = computeIndices(no); 
     398    int sno = getSeries(); 
    392399    int fno = q[0], ino = q[1]; 
    393     if (ino < readers[fno].getImageCount()) { 
    394       return readers[fno].openBytes(ino); 
     400    if (ino < readers[sno][fno].getImageCount()) { 
     401      return readers[sno][fno].openBytes(ino); 
    395402    } 
    396403 
    397404    // return a blank image to cover for the fact that 
    398405    // this file does not contain enough image planes 
    399     int sno = getSeries(); 
    400406    if (blankBytes[sno] == null) { 
    401407      int bytes = FormatTools.getBytesPerPixel(getPixelType()); 
     
    421427    FormatTools.assertId(currentId, true, 2); 
    422428    int[] q = computeIndices(no); 
     429    int sno = getSeries(); 
    423430    int fno = q[0], ino = q[1]; 
    424     if (ino < readers[fno].getImageCount()) { 
    425       return readers[fno].openBytes(ino, buf); 
     431    if (ino < readers[sno][fno].getImageCount()) { 
     432      return readers[sno][fno].openBytes(ino, buf); 
    426433    } 
    427434 
     
    468475    FormatTools.assertId(currentId, true, 2); 
    469476    int[] q = computeIndices(no); 
     477    int sno = getSeries(); 
    470478    int fno = q[0], ino = q[1]; 
    471     if (ino < readers[fno].getImageCount()) { 
    472       return readers[fno].openThumbImage(ino); 
     479    if (ino < readers[sno][fno].getImageCount()) { 
     480      return readers[sno][fno].openThumbImage(ino); 
    473481    } 
    474482 
    475483    // return a blank image to cover for the fact that 
    476484    // this file does not contain enough image planes 
    477     int sno = getSeries(); 
    478485    if (blankThumb[sno] == null) { 
    479486      blankThumb[sno] = ImageTools.blankImage(getThumbSizeX(), 
     
    487494    FormatTools.assertId(currentId, true, 2); 
    488495    int[] q = computeIndices(no); 
     496    int sno = getSeries(); 
    489497    int fno = q[0], ino = q[1]; 
    490     if (ino < readers[fno].getImageCount()) { 
    491       return readers[fno].openThumbBytes(ino); 
     498    if (ino < readers[sno][fno].getImageCount()) { 
     499      return readers[sno][fno].openThumbBytes(ino); 
    492500    } 
    493501 
    494502    // return a blank image to cover for the fact that 
    495503    // this file does not contain enough image planes 
    496     int sno = getSeries(); 
    497504    if (blankThumbBytes[sno] == null) { 
    498505      int bytes = FormatTools.getBytesPerPixel(getPixelType()); 
     
    507514    if (readers == null) reader.close(fileOnly); 
    508515    else { 
    509       for (int i=0; i<readers.length; i++) readers[i].close(fileOnly); 
     516      for (int i=0; i<readers.length; i++) { 
     517        for (int j=0; j<readers[i].length; j++) { 
     518          readers[i][j].close(fileOnly); 
     519        } 
     520      } 
    510521    } 
    511522    if (!fileOnly) { 
     
    521532    if (readers == null) reader.close(); 
    522533    else { 
    523       for (int i=0; i<readers.length; i++) readers[i].close(); 
     534      for (int i=0; i<readers.length; i++) { 
     535        for (int j=0; j<readers[i].length; j++) { 
     536          readers[i][j].close(); 
     537        } 
     538      } 
    524539    } 
    525540    readers = null; 
     
    532547  public int getSeriesCount() { 
    533548    FormatTools.assertId(currentId, true, 2); 
    534     return reader.getSeriesCount(); 
     549    return core.sizeX.length; 
    535550  } 
    536551 
     
    538553  public void setSeries(int no) { 
    539554    FormatTools.assertId(currentId, true, 2); 
    540     reader.setSeries(no); 
     555    int n = reader.getSeriesCount(); 
     556    if (n > 1) reader.setSeries(no); 
     557    else series = no; 
    541558  } 
    542559 
     
    544561  public int getSeries() { 
    545562    FormatTools.assertId(currentId, true, 2); 
    546     return reader.getSeries(); 
     563    return series == 0 ? reader.getSeries() : series; 
    547564  } 
    548565 
    549566  /* @see IFormatReader#setGroupFiles(boolean) */ 
    550567  public void setGroupFiles(boolean group) { 
    551     for (int i=0; i<readers.length; i++) readers[i].setGroupFiles(group); 
     568    for (int i=0; i<readers.length; i++) { 
     569      for (int j=0; j<readers[i].length; j++) { 
     570        readers[i][j].setGroupFiles(group); 
     571      } 
     572    } 
    552573  } 
    553574 
    554575  /* @see IFormatReader#isGroupFiles() */ 
    555576  public boolean isGroupFiles() { 
    556     return readers[0].isGroupFiles(); 
     577    return readers[0][0].isGroupFiles(); 
    557578  } 
    558579 
    559580  /* @see IFormatReader#fileGroupOption(String) */ 
    560581  public int fileGroupOption(String id) throws FormatException, IOException { 
    561     return readers[0].fileGroupOption(id); 
     582    return readers[0][0].fileGroupOption(id); 
    562583  } 
    563584 
    564585  /* @see IFormatReader#isMetadataComplete() */ 
    565586  public boolean isMetadataComplete() { 
    566     return readers[0].isMetadataComplete(); 
     587    return readers[0][0].isMetadataComplete(); 
    567588  } 
    568589 
     
    573594    else { 
    574595      for (int i=0; i<readers.length; i++) { 
    575         readers[i].setNormalized(normalize); 
     596        for (int j=0; j<readers[i].length; j++) { 
     597          readers[i][j].setNormalized(normalize); 
     598        } 
    576599      } 
    577600    } 
     
    587610    else { 
    588611      for (int i=0; i<readers.length; i++) { 
    589         readers[i].setMetadataCollected(collect); 
     612        for (int j=0; j<readers[i].length; j++) { 
     613          readers[i][j].setMetadataCollected(collect); 
     614        } 
    590615      } 
    591616    } 
     
    603628    else { 
    604629      for (int i=0; i<readers.length; i++) { 
    605         readers[i].setOriginalMetadataPopulated(populate); 
     630        for (int j=0; j<readers[i].length; j++) { 
     631          readers[i][j].setOriginalMetadataPopulated(populate); 
     632        } 
    606633      } 
    607634    } 
     
    626653      // we have no datasets structured this way, so this logic is untested 
    627654      if (usedFiles == null) { 
    628         String[][] used = new String[files.length][]; 
     655        String[][][] used = new String[files.length][][]; 
    629656        int total = 0; 
    630657        for (int i=0; i<files.length; i++) { 
    631           try { 
    632             readers[i].setId(files[i]); 
     658          for (int j=0; j<files[i].length; j++) { 
     659            try { 
     660              readers[i][j].setId(files[i][j]); 
     661            } 
     662            catch (FormatException exc) { 
     663              LogTools.trace(exc); 
     664              return null; 
     665            } 
     666            catch (IOException exc) { 
     667              LogTools.trace(exc); 
     668             return null; 
     669            }  
     670            used[i][j] = readers[i][j].getUsedFiles(); 
     671            total += used[i][j].length; 
    633672          } 
    634           catch (FormatException exc) { 
    635             LogTools.trace(exc); 
    636             return null; 
    637           } 
    638           catch (IOException exc) { 
    639             LogTools.trace(exc); 
    640             return null; 
    641           } 
    642           used[i] = readers[i].getUsedFiles(); 
    643           total += used[i].length; 
    644673        } 
    645674        usedFiles = new String[total]; 
    646675        for (int i=0, off=0; i<used.length; i++) { 
    647           System.arraycopy(used[i], 0, usedFiles, off, used[i].length); 
    648           off += used[i].length; 
     676          for (int j=0; j<used[i].length; j++) { 
     677            System.arraycopy(used[i][j], 0, usedFiles, off, used[i][j].length); 
     678            off += used[i][j].length; 
     679          } 
    649680        } 
    650681      } 
     
    654685    // this logic could fail if the first constituent has no extra used files, 
    655686    // but later constituents do; in practice, this scenario seems unlikely 
    656     return files; 
     687    Vector v = new Vector(); 
     688    for (int i=0; i<files.length; i++) { 
     689      for (int j=0; j<files[i].length; j++) { 
     690        v.add(files[i][j]); 
     691      } 
     692    } 
     693    return (String[]) v.toArray(new String[0]); 
    657694  } 
    658695 
     
    719756  /* @see IFormatReader#getUnderlyingReaders() */ 
    720757  public IFormatReader[] getUnderlyingReaders() { 
    721     return readers; 
     758    Vector v = new Vector(); 
     759    for (int i=0; i<readers.length; i++) { 
     760      for (int j=0; j<readers[i].length; j++) { 
     761        v.add(readers[i][j]); 
     762      } 
     763    } 
     764    return (IFormatReader[]) v.toArray(new IFormatReader[0]); 
    722765  } 
    723766 
     
    751794    if (readers == null) reader.addStatusListener(l); 
    752795    else { 
    753       for (int i=0; i<readers.length; i++) readers[i].addStatusListener(l); 
     796      for (int i=0; i<readers.length; i++) { 
     797        for (int j=0; j<readers[i].length; j++) { 
     798          readers[i][j].addStatusListener(l); 
     799        } 
     800      } 
    754801    } 
    755802  } 
     
    759806    if (readers == null) reader.removeStatusListener(l); 
    760807    else { 
    761       for (int i=0; i<readers.length; i++) readers[i].removeStatusListener(l); 
     808      for (int i=0; i<readers.length; i++) { 
     809        for (int j=0; j<readers[i].length; j++) { 
     810          readers[i][j].removeStatusListener(l); 
     811        } 
     812      } 
    762813    } 
    763814  } 
     
    778829    currentId = id; 
    779830    fp = findPattern(id); 
     831 
     832    reader.setId(fp.getFiles()[0]); 
     833 
     834    // if this is a multi-series dataset, we need some special logic 
     835    AxisGuesser guesser = new AxisGuesser(fp, reader.getDimensionOrder(), 
     836      reader.getSizeZ(), reader.getSizeT(), reader.getEffectiveSizeC(), 
     837      reader.isOrderCertain()); 
     838 
     839    int seriesCount = reader.getSeriesCount(); 
     840    boolean seriesInFile = true; 
     841    if (guesser.getAxisCountS() > 0) { 
     842      int[] count = fp.getCount(); 
     843      int[] axes = guesser.getAxisTypes(); 
     844 
     845      seriesInFile = false; 
     846 
     847      String[] blockPrefixes = fp.getPrefixes(); 
     848      BigInteger[] firsts = fp.getFirst(); 
     849      BigInteger[] steps = fp.getStep(); 
     850      String sBlock = null; 
     851      BigInteger first = null; 
     852      BigInteger step = null; 
     853 
     854      for (int i=0; i<axes.length; i++) { 
     855        if (axes[i] == AxisGuesser.S_AXIS) { 
     856          seriesCount = count[i]; 
     857          sBlock = blockPrefixes[i]; 
     858          first = firsts[i]; 
     859          step = steps[i]; 
     860        } 
     861      } 
     862 
     863      files = new String[seriesCount][]; 
     864 
     865      String file = fp.getFiles()[0]; 
     866      String dir = 
     867        new Location(file).getAbsoluteFile().getParentFile().getPath(); 
     868      String prefix = fp.getPrefix(); 
     869      String suffix = fp.getSuffix(); 
     870 
     871      Vector[] v = new Vector[seriesCount]; 
     872      for (int i=0; i<v.length; i++) { 
     873        v[i] = new Vector(); 
     874      } 
     875      String[] list = new Location(dir).list(); 
     876      for (int i=0; i<list.length; i++) { 
     877        if (list[i].indexOf(File.separator) != -1) { 
     878          list[i] = list[i].substring(list[i].lastIndexOf(File.separator)); 
     879        } 
     880        if (list[i].startsWith(prefix) && list[i].endsWith(suffix)) { 
     881          for (int j=0; j<seriesCount; j++) { 
     882            BigInteger bb = new BigInteger(j + ""); 
     883            bb = bb.multiply(step); 
     884            bb = bb.add(first); 
     885            if (list[i].indexOf(sBlock + bb.toString()) != -1) { 
     886              v[j].add(list[i]); 
     887              break; 
     888            } 
     889          } 
     890        } 
     891      } 
     892 
     893      for (int i=0; i<seriesCount; i++) { 
     894        String[] test = (String[]) v[i].toArray(new String[0]); 
     895        String p = FilePattern.findPattern(test[0], dir, test); 
     896        FilePattern pat = new FilePattern(p); 
     897        files[i] = pat.getFiles(); 
     898      } 
     899    } 
    780900 
    781901    // verify that file pattern is valid and matches existing files 
     
    786906        " (" + currentId + "): " + fp.getErrorMessage() + msg); 
    787907    } 
    788     files = fp.getFiles(); 
     908    if (files == null) { 
     909      files = new String[1][]; 
     910      files[0] = fp.getFiles(); 
     911    } 
    789912 
    790913    if (files == null) { 
     
    793916    } 
    794917    for (int i=0; i<files.length; i++) { 
    795       if (!new Location(files[i]).exists()) { 
    796         throw new FormatException("File #" + i + 
    797           " (" + files[i] + ") does not exist."); 
     918      for (int j=0; j<files[i].length; j++) { 
     919        if (!new Location(files[i][j]).exists()) { 
     920          throw new FormatException("File #" + i + 
     921            " (" + files[i] + ") does not exist."); 
     922        } 
    798923      } 
    799924    } 
     
    806931      r = ((ReaderWrapper) r).getReader(); 
    807932    } 
    808     if (r instanceof ImageReader) r = ((ImageReader) r).getReader(files[0]); 
     933    if (r instanceof ImageReader) r = ((ImageReader) r).getReader(files[0][0]); 
    809934    classes.add(r.getClass()); 
    810935 
    811936    // construct list of readers for all files 
    812     readers = new IFormatReader[files.length]; 
    813     readers[0] = reader; 
    814     for (int i=1; i<readers.length; i++) { 
    815       // use crazy reflection to instantiate a reader of the proper type 
    816       try { 
    817         r = null; 
    818         for (int j=classes.size()-1; j>=0; j--) { 
    819           Class c = (Class) classes.elementAt(j); 
    820           if (r == null) r = (IFormatReader) c.newInstance(); 
    821           else { 
    822             r = (IFormatReader) c.getConstructor( 
    823               new Class[] {IFormatReader.class}).newInstance(new Object[] {r}); 
     937    readers = new IFormatReader[files.length][]; 
     938    for (int i=0; i<readers.length; i++) { 
     939      readers[i] = new IFormatReader[files[i].length]; 
     940    } 
     941 
     942    readers[0][0] = reader; 
     943    for (int i=0; i<readers.length; i++) { 
     944      for (int j=0; j<readers[i].length; j++) { 
     945        // use crazy reflection to instantiate a reader of the proper type 
     946        try { 
     947          r = null; 
     948          for (int k=classes.size()-1; k>=0; k--) { 
     949            Class c = (Class) classes.elementAt(k); 
     950            if (r == null) r = (IFormatReader) c.newInstance(); 
     951            else { 
     952              r = (IFormatReader) c.getConstructor(new Class[] 
     953                {IFormatReader.class}).newInstance(new Object[] {r}); 
     954            } 
    824955          } 
    825         } 
    826         readers[i] = (IFormatReader) r; 
    827       } 
    828       catch (InstantiationException exc) { LogTools.trace(exc); } 
    829       catch (IllegalAccessException exc) { LogTools.trace(exc); } 
    830       catch (NoSuchMethodException exc) { LogTools.trace(exc); } 
    831       catch (InvocationTargetException exc) { LogTools.trace(exc); } 
     956          readers[i][j] = (IFormatReader) r; 
     957        } 
     958        catch (InstantiationException exc) { LogTools.trace(exc); } 
     959        catch (IllegalAccessException exc) { LogTools.trace(exc); } 
     960        catch (NoSuchMethodException exc) { LogTools.trace(exc); } 
     961        catch (InvocationTargetException exc) { LogTools.trace(exc); } 
     962      } 
    832963    } 
    833964 
     
    837968    boolean metadataCollected = reader.isMetadataCollected(); 
    838969    StatusListener[] statusListeners = reader.getStatusListeners(); 
    839     for (int i=1; i<readers.length; i++) { 
    840       readers[i].setNormalized(normalized); 
    841       readers[i].setMetadataFiltered(metadataFiltered); 
    842       readers[i].setMetadataCollected(metadataCollected); 
    843       for (int j=0; j<statusListeners.length; j++) { 
    844         readers[i].addStatusListener(statusListeners[j]); 
    845       } 
    846     } 
    847  
    848     reader.setId(files[0]); 
     970    for (int i=0; i<readers.length; i++) { 
     971      for (int j=0; j<readers[i].length; j++) { 
     972        readers[i][j].setNormalized(normalized); 
     973        readers[i][j].setMetadataFiltered(metadataFiltered); 
     974        readers[i][j].setMetadataCollected(metadataCollected); 
     975        for (int k=0; k<statusListeners.length; k++) { 
     976          readers[i][j].addStatusListener(statusListeners[k]); 
     977        } 
     978      } 
     979    } 
    849980 
    850981    String[] originalUsedFiles = reader.getUsedFiles(); 
     
    852983    boolean doNotStitch = true; 
    853984    for (int i=0; i<files.length; i++) { 
    854       boolean found = false; 
    855       for (int j=0; j<originalUsedFiles.length; j++) { 
    856         if (originalUsedFiles[j].endsWith(files[i])) { 
    857           found = true; 
     985      for (int k=0; k<files[i].length; k++) { 
     986        boolean found = false; 
     987        for (int j=0; j<originalUsedFiles.length; j++) { 
     988          if (originalUsedFiles[j].endsWith(files[i][k])) { 
     989            found = true; 
     990            break; 
     991          } 
     992        } 
     993        if (!found) { 
     994          doNotStitch = false; 
    858995          break; 
    859996        } 
    860       } 
    861       if (!found) { 
    862         doNotStitch = false; 
    863         break; 
    864997      } 
    865998    } 
     
    8681001      // the reader for this file uses its own stitching logic that is probably 
    8691002      // smarter than FileStitcher 
    870       readers = new IFormatReader[] {reader}; 
    871       files = new String[] {files[0]}; 
    872       fp = new FilePattern(files[0]); 
    873     } 
    874  
    875     int seriesCount = reader.getSeriesCount(); 
     1003      readers = new IFormatReader[1][1]; 
     1004      readers[0][0] = reader; 
     1005      String f = files[0][0]; 
     1006      files = new String[1][1]; 
     1007      files[0][0] = f; 
     1008      fp = new FilePattern(files[0][0]); 
     1009    } 
     1010 
    8761011    ag = new AxisGuesser[seriesCount]; 
    8771012    blankImage = new BufferedImage[seriesCount]; 
     
    8911026    core = new CoreMetadata(seriesCount); 
    8921027    int oldSeries = reader.getSeries(); 
     1028    IFormatReader rr = reader; 
    8931029    for (int i=0; i<seriesCount; i++) { 
    894       reader.setSeries(i); 
    895       core.sizeX[i] = reader.getSizeX(); 
    896       core.sizeY[i] = reader.getSizeY(); 
     1030      if (seriesInFile) rr.setSeries(i); 
     1031      else { 
     1032        rr = readers[i][0]; 
     1033        rr.setId(files[i][0]); 
     1034      } 
     1035 
     1036      core.sizeX[i] = rr.getSizeX(); 
     1037      core.sizeY[i] = rr.getSizeY(); 
    8971038      // NB: core.sizeZ populated in computeAxisLengths below 
    8981039      // NB: core.sizeC populated in computeAxisLengths below 
    8991040      // NB: core.sizeT populated in computeAxisLengths below 
    900       core.pixelType[i] = reader.getPixelType(); 
    901       imagesPerFile[i] = reader.getImageCount(); 
    902       core.imageCount[i] = files.length * imagesPerFile[i]; 
    903       core.thumbSizeX[i] = reader.getThumbSizeX(); 
    904       core.thumbSizeY[i] = reader.getThumbSizeY(); 
     1041      core.pixelType[i] = rr.getPixelType(); 
     1042      imagesPerFile[i] = rr.getImageCount(); 
     1043      core.imageCount[i] = files[i].length * imagesPerFile[i]; 
     1044      core.thumbSizeX[i] = rr.getThumbSizeX(); 
     1045      core.thumbSizeY[i] = rr.getThumbSizeY(); 
    9051046      // NB: core.cLengths[i] populated in computeAxisLengths below 
    9061047      // NB: core.cTypes[i] populated in computeAxisLengths below 
    907       core.currentOrder[i] = reader.getDimensionOrder(); 
     1048      core.currentOrder[i] = rr.getDimensionOrder(); 
    9081049      // NB: core.orderCertain[i] populated below 
    909       core.rgb[i] = reader.isRGB(); 
    910       core.littleEndian[i] = reader.isLittleEndian(); 
    911       core.interleaved[i] = reader.isInterleaved(); 
    912       core.seriesMetadata[i] = reader.getMetadata(); 
    913       sizeZ[i] = reader.getSizeZ(); 
    914       sizeC[i] = reader.getSizeC(); 
    915       sizeT[i] = reader.getSizeT(); 
    916       certain[i] = reader.isOrderCertain(); 
     1050      core.rgb[i] = rr.isRGB(); 
     1051      core.littleEndian[i] = rr.isLittleEndian(); 
     1052      core.interleaved[i] = rr.isInterleaved(); 
     1053      core.seriesMetadata[i] = rr.getMetadata(); 
     1054      sizeZ[i] = rr.getSizeZ(); 
     1055      sizeC[i] = rr.getSizeC(); 
     1056      sizeT[i] = rr.getSizeT(); 
     1057      certain[i] = rr.isOrderCertain(); 
    9171058    } 
    9181059    reader.setSeries(oldSeries); 
     
    9411082    int sno = getSeries(); 
    9421083 
    943     int[] count = fp.getCount(); 
     1084    FilePattern p = new FilePattern(FilePattern.findPattern(files[sno][0], 
     1085      new Location(files[sno][0]).getAbsoluteFile().getParentFile().getPath(), 
     1086      files[sno])); 
     1087 
     1088    int[] count = p.getCount(); 
     1089 
     1090    try { 
     1091      readers[sno][0].setId(files[sno][0]); 
     1092    } 
     1093    catch (IOException e) { 
     1094      throw new FormatException(e); 
     1095    } 
     1096 
     1097    ag[sno] = new AxisGuesser(p, readers[sno][0].getDimensionOrder(), 
     1098      readers[sno][0].getSizeZ(), readers[sno][0].getSizeT(), 
     1099      readers[sno][0].getSizeC(), readers[sno][0].isOrderCertain()); 
    9441100    int[] axes = ag[sno].getAxisTypes(); 
    9451101    int numZ = ag[sno].getAxisCountZ(); 
     
    9561112    lenC[sno][0] = sizeC[sno]; 
    9571113    lenT[sno][0] = sizeT[sno]; 
    958     for (int i=0, z=1, c=1, t=1; i<axes.length; i++) { 
     1114 
     1115    for (int i=0, z=1, c=1, t=1; i<count.length; i++) { 
    9591116      switch (axes[i]) { 
    9601117        case AxisGuesser.Z_AXIS: 
     
    9701127          lenT[sno][t++] = count[i]; 
    9711128          break; 
     1129        case AxisGuesser.S_AXIS: 
     1130          break; 
    9721131        default: 
    9731132          throw new FormatException("Unknown axis type for axis #" + 
     
    10511210 
    10521211    // configure the reader, in case we haven't done this one yet 
    1053     readers[fno].setId(files[fno]); 
    1054     readers[fno].setSeries(reader.getSeries()); 
     1212    readers[sno][fno].setId(files[sno][fno]); 
     1213    readers[sno][fno].setSeries(reader.getSeries()); 
    10551214 
    10561215    int ino; 
    1057     if (posZ[0] < readers[fno].getSizeZ() && 
    1058       posC[0] < readers[fno].getSizeC() && posT[0] < readers[fno].getSizeT()) 
     1216    if (posZ[0] < readers[sno][fno].getSizeZ() && 
     1217      posC[0] < readers[sno][fno].getSizeC() && 
     1218      posT[0] < readers[sno][fno].getSizeT()) 
    10591219    { 
    1060       ino = FormatTools.getIndex(readers[fno], posZ[0], posC[0], posT[0]); 
     1220      ino = FormatTools.getIndex(readers[sno][fno], posZ[0], posC[0], posT[0]); 
    10611221    } 
    10621222    else ino = Integer.MAX_VALUE; // coordinates out of range 
Note: See TracChangeset for help on using the changeset viewer.