Changeset 3228


Ignore:
Timestamp:
10/05/07 10:51:48 (12 years ago)
Author:
curtis
Message:

Progress on OME-TIFF sample file generator. Currently generates plain TIFFs.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/utils/MakeTestOmeTiff.java

    r3224 r3228  
    44 
    55import java.awt.*; 
    6 import java.awt.font.FontRenderContext; 
    76import java.awt.image.BufferedImage; 
    87import java.awt.geom.Rectangle2D; 
    9 import loci.formats.gui.ImageViewer;//TEMP 
     8import java.io.IOException; 
     9import java.util.Hashtable; 
     10import java.util.Vector; 
     11import loci.formats.FormatException; 
     12import loci.formats.FormatTools; 
     13import loci.formats.out.TiffWriter; 
    1014 
    1115/** Creates a sample OME-TIFF dataset according to the given parameters. */ 
    1216public class MakeTestOmeTiff { 
    1317 
    14   public static void main(String[] args) { 
    15     int paramCount = 5; 
    16     if (args == null || args.length == 0 || args.length % paramCount != 0) { 
    17       System.out.println("Usage: java MakeTestOmeTiff"); 
    18       System.out.println("\tseries1_SizeX series1_SizeY series1_SizeZ " + 
    19         "series1_SizeC series1_SizeT"); 
    20       System.out.println("\t[series2_SizeX series2_SizeY series2_SizeZ " + 
    21         "series2_SizeC series2_SizeT]"); 
     18  private static int gradient(int type, int num, int total) { 
     19    final int max = 96; 
     20    int split = type / 2 + 1; 
     21    boolean reverse = type % 2 == 0; 
     22    int v = max; 
     23    total /= split; 
     24    for (int i=1; i<=split+1; i++) { 
     25      if (num < i * total) { 
     26        if (i % 2 == 0) v = max * (num % total) / total; 
     27        else v = max * (total - num % total) / total; 
     28        break; 
     29      } 
     30    } 
     31    if (reverse) v = max - v; 
     32    return v; 
     33  } 
     34 
     35  public static void main(String[] args) throws FormatException, IOException { 
     36    int leadParams = 2, paramCount = 6; 
     37    boolean usage = false, scramble = false; 
     38    if (args == null || args.length < leadParams + paramCount) usage = true; 
     39    else { 
     40      int parity = (args.length - leadParams) % paramCount; 
     41      scramble = args[2].equalsIgnoreCase("-scramble"); 
     42      if (parity != (scramble ? 1 : 0)) usage = true; 
     43    } 
     44    if (usage) { 
     45      System.out.println("Usage: java MakeTestOmeTiff name dist [-scramble]"); 
     46      System.out.println("\tseries1_SizeX series1_SizeY series1_SizeZ"); 
     47      System.out.println("\tseries1_SizeC series1_SizeT series1_DimOrder"); 
     48      System.out.println("\t[series2_SizeX series2_SizeY series2_SizeZ"); 
     49      System.out.println("\tseries2_SizeC series2_SizeT series2_DimOrder]"); 
    2250      System.out.println("\t[...]"); 
     51      System.out.println(); 
     52      System.out.println("  name: prefix for filenames"); 
     53      System.out.println("  dist: code for how to distribute across files:"); 
     54      System.out.println("    szct = all series + planes in one master file"); 
     55      System.out.println("    zct = each series in its own file"); 
     56      System.out.println("    zc = all Z + C positions per file"); 
     57      System.out.println("    zt = all Z + T positions per file"); 
     58      System.out.println("    ct = all C + T positions per file"); 
     59      System.out.println("    z = all Z positions per file"); 
     60      System.out.println("    c = all C positions per file"); 
     61      System.out.println("    t = all T positions per file"); 
     62      System.out.println("    x = single plane per file"); 
     63      System.out.println("  -scramble: randomizes IFD ordering"); 
     64      System.out.println("  series*_SizeX: width of image planes"); 
     65      System.out.println("  series*_SizeY: height of image planes"); 
     66      System.out.println("  series*_SizeZ: number of focal planes"); 
     67      System.out.println("  series*_SizeC: number of channels"); 
     68      System.out.println("  series*_SizeT: number of time points"); 
     69      System.out.println("  series*_DimOrder: planar ordering: " + 
     70        "xyzct, xyztc, xyczt, xyctz, xytzc, xytcz"); 
     71      System.out.println(); 
     72      System.out.println("Example:"); 
     73      System.out.println("\tjava MakeTestOmeTiff test-image zct \\"); 
     74      System.out.println("\t517 239 5 3 4 xyzct 431 555 1 2 7 xytcz"); 
    2375      System.exit(1); 
    2476    } 
    25     int numSeries = args.length / paramCount; 
     77    String name = args[0]; 
     78    String dist = args[1].toLowerCase(); 
     79    int numSeries = (args.length - leadParams) / paramCount; 
    2680    int[] sizeX = new int[numSeries]; 
    2781    int[] sizeY = new int[numSeries]; 
     
    2983    int[] sizeC = new int[numSeries]; 
    3084    int[] sizeT = new int[numSeries]; 
    31     int totalPlanes = 0; 
    32     for (int i=0; i<numSeries; i++) { 
    33       sizeX[i] = Integer.parseInt(args[paramCount * i]); 
    34       sizeY[i] = Integer.parseInt(args[paramCount * i + 1]); 
    35       sizeZ[i] = Integer.parseInt(args[paramCount * i + 2]); 
    36       sizeC[i] = Integer.parseInt(args[paramCount * i + 3]); 
    37       sizeT[i] = Integer.parseInt(args[paramCount * i + 4]); 
    38       totalPlanes += sizeZ[i] * sizeC[i] * sizeT[i]; 
    39     } 
    40     BufferedImage[] images = new BufferedImage[totalPlanes]; 
     85    String[] dimOrder = new String[numSeries]; 
     86    BufferedImage[][] images = new BufferedImage[numSeries][]; 
     87    for (int s=0; s<numSeries; s++) { 
     88      sizeX[s] = Integer.parseInt(args[leadParams + paramCount * s]); 
     89      sizeY[s] = Integer.parseInt(args[leadParams + paramCount * s + 1]); 
     90      sizeZ[s] = Integer.parseInt(args[leadParams + paramCount * s + 2]); 
     91      sizeC[s] = Integer.parseInt(args[leadParams + paramCount * s + 3]); 
     92      sizeT[s] = Integer.parseInt(args[leadParams + paramCount * s + 4]); 
     93      dimOrder[s] = args[leadParams + paramCount * s + 5].toUpperCase(); 
     94      images[s] = new BufferedImage[sizeZ[s] * sizeC[s] * sizeT[s]]; 
     95    } 
    4196    int ndx = 0; 
    42     for (int s=0; s<numSeries; s++) { 
    43       for (int t=0; t<sizeT[s]; t++) { 
    44         for (int c=0; c<sizeC[s]; c++) { 
    45           for (int z=0; z<sizeZ[s]; z++) { 
    46             images[ndx] = new BufferedImage( 
    47               sizeX[s], sizeY[s], BufferedImage.TYPE_BYTE_GRAY); 
    48             Graphics2D g = images[ndx].createGraphics(); 
    49             // draw gradient 
    50             for (int y=0; y<sizeY[s]; y++) { 
    51               int v = 96 * y / sizeY[s]; 
    52               g.setColor(new Color(v, v, v)); 
    53               g.drawLine(0, y, sizeX[s], y); 
    54             } 
    55             // draw planar information as text 
    56             g.setColor(Color.white); 
    57             Font font = g.getFont(); 
    58             FontRenderContext frc = g.getFontRenderContext(); 
    59             String[] lines = { 
    60               numSeries > 1 ? "Series #" + (s + 1) + "/" + numSeries : "", 
    61               "Resolution = " + sizeX[s] + " x " + sizeY[s], 
    62               "Focal plane = " + (z + 1) + "/" + sizeZ[s], 
    63               "Channel = " + (c + 1) + "/" + sizeC[s], 
    64               "Time point = " + (t + 1) + "/" + sizeT[s] 
    65             }; 
    66             int xoff = 5, yoff = 5; // starting offset for lines of text 
    67             for (int i=0; i<lines.length; i++) { 
    68               Rectangle2D r = font.getStringBounds(lines[i], frc); 
    69               yoff += r.getHeight(); 
    70               g.drawString(lines[i], xoff, yoff); 
    71             } 
    72             g.dispose(); 
    73             ndx++; 
     97 
     98    System.out.println("Generating image planes"); 
     99    for (int s=0; s<numSeries; s++) { 
     100      int len = images[s].length; 
     101      System.out.print("\tSeries #" + (s + 1) + " - " + 
     102        sizeX[s] + " x " + sizeY[s] + ", " + 
     103        sizeZ[s] + "Z " + sizeC[s] + "C " + sizeT[s] + "T"); 
     104      for (int p=0; p<len; p++) { 
     105        int[] zct = FormatTools.getZCTCoords(dimOrder[s], 
     106          sizeZ[s], sizeC[s], sizeT[s], len, p); 
     107 
     108        System.out.print("."); 
     109        images[s][p] = new BufferedImage( 
     110          sizeX[s], sizeY[s], BufferedImage.TYPE_BYTE_GRAY); 
     111        Graphics2D g = images[s][p].createGraphics(); 
     112        // draw gradient 
     113        boolean even = s % 2 == 0; 
     114        int type = s / 2; 
     115        if (even) { 
     116          // draw vertical gradient for even-numbered series 
     117          for (int y=0; y<sizeY[s]; y++) { 
     118            int v = gradient(type, y, sizeY[s]); 
     119            g.setColor(new Color(v, v, v)); 
     120            g.drawLine(0, y, sizeX[s], y); 
    74121          } 
    75122        } 
    76       } 
    77     } 
    78     ImageViewer view = new ImageViewer(); 
    79     view.setImages(images); 
    80     view.setVisible(true); 
     123        else { 
     124          // draw horizontal gradient for odd-numbered series 
     125          for (int x=0; x<sizeX[s]; x++) { 
     126            int v = gradient(type, x, sizeX[s]); 
     127            g.setColor(new Color(v, v, v)); 
     128            g.drawLine(x, 0, x, sizeY[s]); 
     129          } 
     130        } 
     131 
     132        // build list of text lines from planar information 
     133        Vector lines = new Vector(); 
     134        Font font = g.getFont(); 
     135        lines.add(new TextLine(name, font.deriveFont(32f), 5, -5)); 
     136        lines.add(new TextLine(sizeX[s] + " x " + sizeY[s], 
     137          font.deriveFont(Font.ITALIC, 16f), 20, 10)); 
     138        lines.add(new TextLine(dimOrder[s], 
     139          font.deriveFont(Font.ITALIC, 14f), 30, 5)); 
     140        if (numSeries > 1) { 
     141          lines.add(new TextLine("Series #" + (s + 1) + "/" + numSeries, 
     142            font, 20, 5)); 
     143        } 
     144        if (sizeZ[s] > 1) { 
     145          lines.add(new TextLine( 
     146            "Focal plane = " + (zct[0] + 1) + "/" + sizeZ[s], font, 20, 2)); 
     147        } 
     148        if (sizeC[s] > 1) { 
     149          lines.add(new TextLine( 
     150            "Channel = " + (zct[1] + 1) + "/" + sizeC[s], font, 20, 2)); 
     151        } 
     152        if (sizeT[s] > 1) { 
     153          lines.add(new TextLine( 
     154            "Time point = " + (zct[2] + 1) + "/" + sizeT[s], font, 20, 2)); 
     155        } 
     156 
     157        // draw text lines to image 
     158        g.setColor(Color.white); 
     159        int yoff = 0; 
     160        for (int i=0; i<lines.size(); i++) { 
     161          TextLine text = (TextLine) lines.get(i); 
     162          g.setFont(text.font); 
     163          Rectangle2D r = g.getFont().getStringBounds( 
     164            text.line, g.getFontRenderContext()); 
     165          yoff += r.getHeight() + text.ypad; 
     166          g.drawString(text.line, text.xoff, yoff); 
     167        } 
     168        g.dispose(); 
     169      } 
     170      System.out.println(); 
     171    } 
     172 
     173    System.out.println("Writing output files"); 
     174    boolean allS = dist.indexOf("s") >= 0; 
     175    boolean allZ = dist.indexOf("z") >= 0; 
     176    boolean allC = dist.indexOf("c") >= 0; 
     177    boolean allT = dist.indexOf("t") >= 0; 
     178 
     179    // determine filename for each image plane 
     180    String[][] filenames = new String[numSeries][]; 
     181    Hashtable lastHash = new Hashtable(); 
     182    boolean[][] last = new boolean[numSeries][]; 
     183    StringBuffer sb = new StringBuffer(); 
     184    for (int s=0; s<numSeries; s++) { 
     185      int len = images[s].length; 
     186      filenames[s] = new String[len]; 
     187      last[s] = new boolean[len]; 
     188      for (int p=0; p<len; p++) { 
     189        sb.append(name); 
     190        if (!allS) sb.append("_series" + s); 
     191        int[] zct = FormatTools.getZCTCoords(dimOrder[s], 
     192          sizeZ[s], sizeC[s], sizeT[s], len, p); 
     193        if (!allZ) sb.append("_Z" + zct[0]); 
     194        if (!allC) sb.append("_C" + zct[1]); 
     195        if (!allT) sb.append("_T" + zct[2]); 
     196        sb.append(".ome.tif"); 
     197        filenames[s][p] = sb.toString(); 
     198        sb.setLength(0); 
     199        last[s][p] = true; 
     200 
     201        // update last flag for this filename 
     202        String key = filenames[s][p]; 
     203        ImageIndex index = (ImageIndex) lastHash.get(key); 
     204        if (index != null) last[index.series][index.plane] = false; 
     205        lastHash.put(key, new ImageIndex(s, p)); 
     206      } 
     207    } 
     208 
     209    TiffWriter out = new TiffWriter(); 
     210    for (int s=0; s<numSeries; s++) { 
     211      int len = images[s].length; 
     212      System.out.println("\tSeries #" + (s + 1) + " - " + 
     213        sizeX[s] + " x " + sizeY[s] + ", " + 
     214        sizeZ[s] + "Z " + sizeC[s] + "C " + sizeT[s] + "T:"); 
     215      for (int p=0; p<len; p++) { 
     216        int[] zct = FormatTools.getZCTCoords(dimOrder[s], 
     217          sizeZ[s], sizeC[s], sizeT[s], len, p); 
     218        System.out.println("\t\tZ" + zct[0] + " C" + zct[1] + 
     219          " T" + zct[2] + " -> " + filenames[s][p] + (last[s][p] ? "*" : "")); 
     220        out.setId(filenames[s][p]); 
     221        out.saveImage(images[s][p], last[s][p]); 
     222      } 
     223    } 
     224//    loci.formats.gui.ImageViewer view = new loci.formats.gui.ImageViewer(); 
     225//    view.setImages(images[0]); 
     226//    view.setVisible(true); 
     227  } 
     228 
     229  private static class TextLine { 
     230    private String line; 
     231    private Font font; 
     232    private int xoff; 
     233    private int ypad; 
     234    private TextLine(String line, Font font, int xoff, int ypad) { 
     235      this.line = line; 
     236      this.font = font; 
     237      this.xoff = xoff; 
     238      this.ypad = ypad; 
     239    } 
     240  } 
     241 
     242  private static class ImageIndex { 
     243    private int series; 
     244    private int plane; 
     245    private ImageIndex(int series, int plane) { 
     246      this.series = series; 
     247      this.plane = plane; 
     248    } 
    81249  } 
    82250 
Note: See TracChangeset for help on using the changeset viewer.