Changeset 7498


Ignore:
Timestamp:
01/11/11 09:03:46 (9 years ago)
Author:
melissa
Message:

Backported ScreenReader to 4.2.

Location:
branches/4.2/components/bio-formats/src/loci/formats
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed
  • branches/4.2/components/bio-formats/src/loci/formats/in/ScreenReader.java

    r7333 r7498  
    2727import java.io.IOException; 
    2828import java.util.Arrays; 
     29import java.util.Comparator; 
    2930import java.util.Vector; 
    3031 
    3132import loci.common.Location; 
    3233import loci.common.RandomAccessInputStream; 
     34import loci.common.services.DependencyException; 
     35import loci.common.services.ServiceException; 
     36import loci.common.services.ServiceFactory; 
     37import loci.formats.ClassList; 
    3338import loci.formats.CoreMetadata; 
    3439import loci.formats.FormatException; 
    3540import loci.formats.FormatReader; 
    3641import loci.formats.FormatTools; 
     42import loci.formats.IFormatReader; 
    3743import loci.formats.ImageReader; 
    3844import loci.formats.MetadataTools; 
     45import loci.formats.MissingLibraryException; 
    3946import loci.formats.meta.MetadataStore; 
    40  
     47import loci.formats.ome.OMEXMLMetadata; 
     48import loci.formats.ome.OMEXMLMetadataImpl; 
     49import loci.formats.services.OMEXMLService; 
     50import loci.formats.services.OMEXMLServiceImpl; 
     51 
     52import ome.xml.model.Image; 
     53import ome.xml.model.OME; 
    4154import ome.xml.model.enums.NamingConvention; 
    4255import ome.xml.model.primitives.NonNegativeInteger; 
     
    5770  // -- Fields -- 
    5871 
     72  private String[] screenMetadataFiles; 
     73  private String[][] plateMetadataFiles; 
     74 
    5975  private ImageReader[][] readers; 
    6076  private boolean[][][] plateMaps; 
     77  private ClassList<IFormatReader> validReaders; 
    6178 
    6279  // -- Constructor -- 
     
    6784    suffixSufficient = false; 
    6885    domains = new String[] {FormatTools.HCS_DOMAIN}; 
     86 
     87    ClassList<IFormatReader> classes = ImageReader.getDefaultReaderClasses(); 
     88    Class<? extends IFormatReader>[] classArray = classes.getClasses(); 
     89    validReaders = new ClassList<IFormatReader>(IFormatReader.class); 
     90    for (Class<? extends IFormatReader> c : classArray) { 
     91      if (!c.equals(ScreenReader.class)) { 
     92        validReaders.addClass(c); 
     93      } 
     94    } 
    6995  } 
    7096 
     
    79105  public boolean isThisType(String filename, boolean open) { 
    80106    if (!open) return super.isThisType(filename, open); // no file system access 
    81     return false; 
     107 
     108    Location file = new Location(filename).getAbsoluteFile(); 
     109    String parent = file.getParent(); 
     110    boolean validNames = 
     111      isValidWellName(file.getAbsolutePath()) && isValidPlateName(parent); 
     112 
     113    ImageReader r = new ImageReader(validReaders); 
     114    boolean validFormat = r.isThisType(filename); 
     115    boolean singleFiles = false; 
     116    try { 
     117      singleFiles = r.isSingleFile(filename); 
     118    } 
     119    catch (FormatException e) { } 
     120    catch (IOException e) { } 
     121 
     122    return validNames && validFormat && singleFiles; 
    82123  } 
    83124 
     
    127168 
    128169    int[] spwIndexes = getSPWIndexes(getSeries()); 
    129     return readers[spwIndexes[0]][spwIndexes[1]].getSeriesUsedFiles(noPixels); 
     170    int plate = spwIndexes[0]; 
     171    int well = spwIndexes[1]; 
     172 
     173    Vector<String> files = new Vector<String>(); 
     174    if (screenMetadataFiles != null) { 
     175      for (String f : screenMetadataFiles) { 
     176        files.add(f); 
     177      } 
     178    } 
     179    if (plateMetadataFiles[plate] != null) { 
     180      for (String f : plateMetadataFiles[plate]) { 
     181        files.add(f); 
     182      } 
     183    } 
     184    String[] readerFiles = readers[plate][well].getSeriesUsedFiles(noPixels); 
     185    for (String f : readerFiles) { 
     186      files.add(f); 
     187    } 
     188    return files.toArray(new String[files.size()]); 
    130189  } 
    131190 
     
    143202      readers = null; 
    144203      plateMaps = null; 
     204      plateMetadataFiles = null; 
     205      screenMetadataFiles = null; 
    145206    } 
    146207  } 
     
    161222 
    162223    // build the list of plate directories 
     224    Vector<String> metadataFiles = new Vector<String>(); 
    163225    Vector<String> tmpPlates = new Vector<String>(); 
    164226    String[] screenList = screen.list(true); 
    165227    for (String f : screenList) { 
    166       if (isValidPlateName(f)) { 
    167         tmpPlates.add(new Location(screen, f).getAbsolutePath()); 
    168       } 
    169     } 
     228      Location plateFile = new Location(screen, f).getAbsoluteFile(); 
     229      if (isValidPlateName(plateFile.getAbsolutePath()) && 
     230        hasValidWells(plateFile)) 
     231      { 
     232        tmpPlates.add(plateFile.getAbsolutePath()); 
     233      } 
     234      else if (!plateFile.isDirectory()) { 
     235        metadataFiles.add(plateFile.getAbsolutePath()); 
     236      } 
     237    } 
     238    screenMetadataFiles = 
     239      metadataFiles.toArray(new String[metadataFiles.size()]); 
     240    metadataFiles.clear(); 
     241 
    170242    String[] plates = tmpPlates.toArray(new String[tmpPlates.size()]); 
    171243    Arrays.sort(plates); 
     
    174246    String[][] files = new String[plates.length][]; 
    175247    plateMaps = new boolean[plates.length][][]; 
     248 
     249    Comparator<String> c = new Comparator<String>() { 
     250      public int compare(String s1, String s2) { 
     251        int row1 = (int) (getRow(s1).charAt(0) - 'A'); 
     252        int row2 = (int) (getRow(s2).charAt(0) - 'A'); 
     253 
     254        if (row1 != row2) { 
     255          return row1 - row2; 
     256        } 
     257 
     258        int col1 = Integer.parseInt(getColumn(s1)) - 1; 
     259        int col2 = Integer.parseInt(getColumn(s2)) - 1; 
     260        return col1 - col2; 
     261      } 
     262    }; 
     263 
     264    plateMetadataFiles = new String[plates.length][]; 
    176265 
    177266    // build the list of well files for each plate 
     
    180269    for (int plate=0; plate<plates.length; plate++) { 
    181270      String[] plateList = new Location(plates[plate]).list(true); 
    182       Vector<String> uniqueRows = new Vector<String>(); 
    183       Vector<String> uniqueCols = new Vector<String>(); 
     271      int maxRow = 0, maxCol = 0; 
    184272      for (String well : plateList) { 
    185         if (isValidWellName(well)) { 
    186           tmpWells.add(new Location(plates[plate], well).getAbsolutePath()); 
     273        Location wellFile = new Location(plates[plate], well); 
     274        if (isValidWellName(wellFile.getAbsolutePath())) { 
    187275          String row = getRow(well); 
    188276          String col = getColumn(well); 
    189277 
    190           if (!uniqueRows.contains(row)) { 
    191             uniqueRows.add(row); 
     278          boolean canAdd = true; 
     279          for (String tmpWell : tmpWells) { 
     280            String tmpRow = getRow(tmpWell); 
     281            String tmpCol = getColumn(tmpWell); 
     282            if (tmpRow.equals(row) && tmpCol.equals(col)) { 
     283              canAdd = false; 
     284              break; 
     285            } 
    192286          } 
    193           if (!uniqueCols.contains(col)) { 
    194             uniqueCols.add(col); 
     287          if (!canAdd) continue; 
     288 
     289          tmpWells.add(wellFile.getAbsolutePath()); 
     290 
     291          if ((row.charAt(0) - 'A') > maxRow) { 
     292            maxRow = row.charAt(0) - 'A'; 
    195293          } 
     294          if (Integer.parseInt(col) - 1 > maxCol) { 
     295            maxCol = Integer.parseInt(col) - 1; 
     296          } 
     297        } 
     298        else if (!wellFile.isDirectory()) { 
     299          metadataFiles.add(wellFile.getAbsolutePath()); 
    196300        } 
    197301      } 
    198302      files[plate] = tmpWells.toArray(new String[tmpWells.size()]); 
    199       Arrays.sort(files[plate]); 
     303 
     304      Arrays.sort(files[plate], c); 
    200305      readers[plate] = new ImageReader[files[plate].length]; 
    201306      coreLength += files[plate].length; 
    202307 
    203       plateMaps[plate] = new boolean[uniqueRows.size()][uniqueCols.size()]; 
     308      plateMaps[plate] = new boolean[maxRow + 1][maxCol + 1]; 
     309      plateMetadataFiles[plate] = 
     310        metadataFiles.toArray(new String[metadataFiles.size()]); 
    204311 
    205312      tmpWells.clear(); 
     313      metadataFiles.clear(); 
    206314    } 
    207315 
    208316    // initialize each of the well files 
     317 
     318    OMEXMLMetadata omexmlMeta; 
     319    OMEXMLService service; 
     320    try { 
     321      ServiceFactory factory = new ServiceFactory(); 
     322      service = factory.getInstance(OMEXMLService.class); 
     323      omexmlMeta = service.createOMEXMLMetadata(); 
     324    } 
     325    catch (DependencyException de) { 
     326      throw new MissingLibraryException(OMEXMLServiceImpl.NO_OME_XML_MSG, de); 
     327    } 
     328    catch (ServiceException se) { 
     329      throw new FormatException(se); 
     330    } 
    209331 
    210332    core = new CoreMetadata[coreLength]; 
     
    212334    for (int plate=0; plate<files.length; plate++) { 
    213335      for (int well=0; well<files[plate].length; well++) { 
    214         readers[plate][well] = new ImageReader(); 
     336        readers[plate][well] = new ImageReader(validReaders); 
     337        readers[plate][well].setMetadataStore(omexmlMeta); 
    215338        readers[plate][well].setId(files[plate][well]); 
    216339        core[nextCore++] = readers[plate][well].getCoreMetadata()[0]; 
     
    225348    } 
    226349 
     350    OME root = (OME) omexmlMeta.getRoot(); 
     351    Image img = root.getImage(0); 
     352    for (int i=1; i<core.length; i++) { 
     353      root.addImage(img); 
     354    } 
     355    ((OMEXMLMetadataImpl) omexmlMeta).resolveReferences(); 
     356    omexmlMeta.setRoot(root); 
     357 
    227358    // populate HCS metadata 
    228359 
    229360    MetadataStore store = makeFilterMetadata(); 
     361    service.convertMetadata(omexmlMeta, store); 
    230362    MetadataTools.populatePixels(store, this); 
    231363 
     
    238370      store.setPlateID(plateID, plate); 
    239371      store.setScreenPlateRef(plateID, 0, plate); 
    240       store.setPlateScreenRef(screenID, plate, 0); 
    241372 
    242373      store.setPlateName(new Location(plates[plate]).getName(), plate); 
     
    247378      store.setPlateColumnNamingConvention(NamingConvention.NUMBER, plate); 
    248379 
    249       for (int well=0; well<files[plate].length; well++) { 
    250         int seriesIndex = getSeriesIndex(plate, well); 
    251  
    252         int[] rowAndColumn = getRowAndColumn(plate, well); 
    253         String wellID = MetadataTools.createLSID("Well", plate, well); 
    254         store.setWellID(wellID, plate, well); 
    255         store.setWellColumn( 
    256           new NonNegativeInteger(rowAndColumn[1]), plate, well); 
    257         store.setWellRow(new NonNegativeInteger(rowAndColumn[0]), plate, well); 
    258  
    259         String imageID = MetadataTools.createLSID("Image", seriesIndex); 
    260         String wellSampleID = 
    261           MetadataTools.createLSID("WellSample", plate, well, 0); 
    262         store.setWellSampleID(wellSampleID, plate, well, 0); 
    263         store.setWellSampleImageRef(imageID, plate, well, 0); 
    264         store.setWellSampleIndex( 
    265           new NonNegativeInteger(seriesIndex), plate, well, 0); 
     380      int realWell = 0; 
     381      for (int row=0; row<plateMaps[plate].length; row++) { 
     382        for (int col=0; col<plateMaps[plate][row].length; col++) { 
     383          int well = row * plateMaps[plate][row].length + col; 
     384          String wellID = MetadataTools.createLSID("Well", plate, well); 
     385          store.setWellID(wellID, plate, well); 
     386          store.setWellColumn(new NonNegativeInteger(col), plate, well); 
     387          store.setWellRow(new NonNegativeInteger(row), plate, well); 
     388 
     389          if (plateMaps[plate][row][col]) { 
     390            int seriesIndex = getSeriesIndex(plate, realWell); 
     391            String imageID = MetadataTools.createLSID("Image", seriesIndex); 
     392            store.setImageID(imageID, seriesIndex); 
     393            store.setImageName("Well " + ((char) (row + 'A')) + (col + 1), 
     394              seriesIndex); 
     395            String wellSampleID = 
     396              MetadataTools.createLSID("WellSample", plate, well, 0); 
     397            store.setWellSampleID(wellSampleID, plate, well, 0); 
     398            store.setWellSampleImageRef(imageID, plate, well, 0); 
     399            store.setWellSampleIndex( 
     400              new NonNegativeInteger(seriesIndex), plate, well, 0); 
     401            realWell++; 
     402          } 
     403        } 
    266404      } 
    267405    } 
     
    271409 
    272410  private boolean isValidWellName(String filename) { 
     411    if (new Location(filename).getAbsoluteFile().isDirectory()) return false; 
    273412    String row = getRow(filename); 
    274413    String col = getColumn(filename); 
     
    276415    try { 
    277416      Integer.parseInt(col); 
    278       return true; 
     417      return Character.isLetter(row.charAt(0)); 
    279418    } 
    280419    catch (NumberFormatException e) { } 
     
    284423 
    285424  private boolean isValidPlateName(String filename) { 
    286     return true; 
     425    return new Location(filename).isDirectory(); 
    287426  } 
    288427 
     
    349488  } 
    350489 
     490  private boolean hasValidWells(Location plate) { 
     491    if (!plate.isDirectory()) return false; 
     492    String[] wells = plate.list(true); 
     493    for (String well : wells) { 
     494      if (isValidWellName(new Location(plate, well).getAbsolutePath())) { 
     495        return true; 
     496      } 
     497    } 
     498    return false; 
     499  } 
     500 
    351501  private String getRow(String well) { 
    352502    String wellName = well.substring(well.lastIndexOf(File.separator) + 1); 
     503    char firstChar = Character.toUpperCase(wellName.charAt(0)); 
     504    while (wellName.indexOf("_") > 0 && (firstChar < 'A' || firstChar > 'P')) { 
     505      wellName = wellName.substring(wellName.indexOf("_") + 1); 
     506      firstChar = Character.toUpperCase(wellName.charAt(0)); 
     507    } 
    353508    return wellName.substring(0, 1).toUpperCase(); 
    354509  } 
     
    356511  private String getColumn(String well) { 
    357512    String wellName = well.substring(well.lastIndexOf(File.separator) + 1); 
    358     return wellName.substring(1); 
     513    char firstChar = Character.toUpperCase(wellName.charAt(0)); 
     514    while (wellName.indexOf("_") > 0 && (firstChar < 'A' || firstChar > 'P')) { 
     515      wellName = wellName.substring(wellName.indexOf("_") + 1); 
     516      firstChar = Character.toUpperCase(wellName.charAt(0)); 
     517    } 
     518    int end = wellName.lastIndexOf("_"); 
     519    if (end < 0) end = wellName.lastIndexOf("."); 
     520    if (end < 0) end = wellName.length(); 
     521    return wellName.substring(1, end); 
    359522  } 
    360523 
  • branches/4.2/components/bio-formats/src/loci/formats/readers.txt

    r7265 r7498  
    2323# available to Bio-Formats, and the order in which they should be used. 
    2424# Please do not edit unless you know what you are doing (see reader-guide.txt). 
     25 
     26# generic reader for HCS data 
     27loci.formats.in.ScreenReader 
    2528 
    2629# readers for compressed/archive files 
Note: See TracChangeset for help on using the changeset viewer.