Changeset 3231


Ignore:
Timestamp:
10/05/07 13:14:16 (12 years ago)
Author:
curtis
Message:

Generator now distinguishes between multiple Images vs multiple Pixels.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/utils/MakeTestOmeTiff.java

    r3229 r3231  
    3434 
    3535  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; 
     36    boolean usage = false; 
     37     
     38    // parse command line arguments 
     39    String name = null; 
     40    String dist = null; 
     41    boolean scramble = false; 
     42    int numImages = 0; 
     43    int[] numPixels = null; 
     44    int[][] sizeX = null, sizeY = null; 
     45    int[][] sizeZ = null, sizeC = null, sizeT = null; 
     46    String[][] dimOrder = null; 
     47 
     48    if (args == null || args.length < 2) usage = true; 
    3949    else { 
    40       int parity = (args.length - leadParams) % paramCount; 
    41       scramble = args[2].equalsIgnoreCase("-scramble"); 
    42       if (parity != (scramble ? 1 : 0)) usage = true; 
     50      name = args[0]; 
     51      dist = args[1].toLowerCase(); 
     52      scramble = args.length >= 2 && args[2].equalsIgnoreCase("-scramble"); 
     53 
     54      int startIndex = scramble ? 3 : 2; 
     55 
     56      // count number of images 
     57      int ndx = startIndex; 
     58      while (ndx < args.length) { 
     59        int numPix = Integer.parseInt(args[ndx]); 
     60        ndx += 1 + 6 * numPix; 
     61        numImages++; 
     62      } 
     63 
     64      // parse pixels's dimensional information 
     65      if (ndx > args.length) usage = true; 
     66      else { 
     67        numPixels = new int[numImages]; 
     68        sizeX = new int[numImages][]; 
     69        sizeY = new int[numImages][]; 
     70        sizeZ = new int[numImages][]; 
     71        sizeC = new int[numImages][]; 
     72        sizeT = new int[numImages][]; 
     73        dimOrder = new String[numImages][]; 
     74 
     75        ndx = startIndex; 
     76        for (int i=0; i<numImages; i++) { 
     77          numPixels[i] = Integer.parseInt(args[ndx++]); 
     78          sizeX[i] = new int[numPixels[i]]; 
     79          sizeY[i] = new int[numPixels[i]]; 
     80          sizeZ[i] = new int[numPixels[i]]; 
     81          sizeC[i] = new int[numPixels[i]]; 
     82          sizeT[i] = new int[numPixels[i]]; 
     83          dimOrder[i] = new String[numPixels[i]]; 
     84          for (int p=0; p<numPixels[i]; p++) { 
     85            sizeX[i][p] = Integer.parseInt(args[ndx++]); 
     86            sizeY[i][p] = Integer.parseInt(args[ndx++]); 
     87            sizeZ[i][p] = Integer.parseInt(args[ndx++]); 
     88            sizeC[i][p] = Integer.parseInt(args[ndx++]); 
     89            sizeT[i][p] = Integer.parseInt(args[ndx++]); 
     90            dimOrder[i][p] = args[ndx++].toUpperCase(); 
     91          } 
     92        } 
     93      } 
    4394    } 
    4495 
    4596    if (usage) { 
    46       System.out.println("Usage: java MakeTestOmeTiff name dist [-scramble]"); 
    47       System.out.println("\tseries1_SizeX series1_SizeY series1_SizeZ"); 
    48       System.out.println("\tseries1_SizeC series1_SizeT series1_DimOrder"); 
    49       System.out.println("\t[series2_SizeX series2_SizeY series2_SizeZ"); 
    50       System.out.println("\tseries2_SizeC series2_SizeT series2_DimOrder]"); 
    51       System.out.println("\t[...]"); 
     97      System.out.println( 
     98        "Usage: java MakeTestOmeTiff name dist [-scramble]"); 
     99      System.out.println("         image1_NumPixels"); 
     100      System.out.println("           image1_pixels1_SizeX " + 
     101        "image1_pixels1_SizeY image1_pixels1_SizeZ"); 
     102      System.out.println("             image1_pixels1_SizeC " + 
     103        "image1_pixels1_SizeT image1_pixels1_DimOrder"); 
     104      System.out.println("           image1_pixels2_SizeX " + 
     105        "image1_pixels2_SizeY image1_pixels2_SizeZ"); 
     106      System.out.println("             image1_pixels2_SizeC " + 
     107        "image1_pixels2_SizeT image1_pixels2_DimOrder"); 
     108      System.out.println("           [...]"); 
     109      System.out.println("         image2_NumPixels"); 
     110      System.out.println("           image2_pixels1_SizeX " + 
     111        "image2_pixels1_SizeY image1_pixels1_SizeZ"); 
     112      System.out.println("             image2_pixels1_SizeC " + 
     113        "image2_pixels1_SizeT image1_pixels1_DimOrder"); 
     114      System.out.println("           image2_pixels2_SizeX " + 
     115        "image2_pixels2_SizeY image1_pixels2_SizeZ"); 
     116      System.out.println("             image2_pixels2_SizeC " + 
     117        "image2_pixels2_SizeT image1_pixels2_DimOrder"); 
     118      System.out.println("           [...]"); 
     119      System.out.println("         [...]"); 
    52120      System.out.println(); 
    53121      System.out.println("  name: prefix for filenames"); 
    54122      System.out.println("  dist: code for how to distribute across files:"); 
    55       System.out.println("    szct = all series + planes in one master file"); 
    56       System.out.println("    zct = each series in its own file"); 
     123      System.out.println("    ipzct = all Images + Pixels in one file"); 
     124      System.out.println("    pzct = each Image in its own file"); 
     125      System.out.println("    zct = each Pixels in its own file"); 
    57126      System.out.println("    zc = all Z + C positions per file"); 
    58127      System.out.println("    zt = all Z + T positions per file"); 
     
    63132      System.out.println("    x = single plane per file"); 
    64133      System.out.println("  -scramble: randomizes IFD ordering"); 
    65       System.out.println("  series*_SizeX: width of image planes"); 
    66       System.out.println("  series*_SizeY: height of image planes"); 
    67       System.out.println("  series*_SizeZ: number of focal planes"); 
    68       System.out.println("  series*_SizeC: number of channels"); 
    69       System.out.println("  series*_SizeT: number of time points"); 
    70       System.out.println("  series*_DimOrder: planar ordering: " + 
    71         "xyzct, xyztc, xyczt, xyctz, xytzc, xytcz"); 
     134      System.out.println("  image*_pixels*_SizeX: width of image planes"); 
     135      System.out.println("  image*_pixels*_SizeY: height of image planes"); 
     136      System.out.println("  image*_pixels*_SizeZ: number of focal planes"); 
     137      System.out.println("  image*_pixels*_SizeC: number of channels"); 
     138      System.out.println("  image*_pixels*_SizeT: number of time points"); 
     139      System.out.println("  image*_pixels*_DimOrder: planar ordering:"); 
     140      System.out.println("    XYZCT, XYZTC, XYCZT, XYCTZ, XYTZC, or XYTCZ"); 
    72141      System.out.println(); 
    73142      System.out.println("Example:"); 
    74       System.out.println("\tjava MakeTestOmeTiff test-image zct \\"); 
    75       System.out.println("\t517 239 5 3 4 xyzct 431 555 1 2 7 xytcz"); 
     143      System.out.println("  java MakeTestOmeTiff test ipzct \\"); 
     144      System.out.println("    2 431 555 1 2 7 XYTCZ \\"); 
     145      System.out.println("      348 461 2 1 6 XYZTC \\"); 
     146      System.out.println("    1 517 239 5 3 4 XYCZT"); 
    76147      System.exit(1); 
    77148    } 
    78     String name = args[0]; 
    79     String dist = args[1].toLowerCase(); 
    80     int numSeries = (args.length - leadParams) / paramCount; 
    81     int[] sizeX = new int[numSeries]; 
    82     int[] sizeY = new int[numSeries]; 
    83     int[] sizeZ = new int[numSeries]; 
    84     int[] sizeC = new int[numSeries]; 
    85     int[] sizeT = new int[numSeries]; 
    86     String[] dimOrder = new String[numSeries]; 
    87     BufferedImage[][] images = new BufferedImage[numSeries][]; 
    88     int[] offsets = new int[numSeries]; 
    89     for (int s=0; s<numSeries; s++) { 
    90       sizeX[s] = Integer.parseInt(args[leadParams + paramCount * s]); 
    91       sizeY[s] = Integer.parseInt(args[leadParams + paramCount * s + 1]); 
    92       sizeZ[s] = Integer.parseInt(args[leadParams + paramCount * s + 2]); 
    93       sizeC[s] = Integer.parseInt(args[leadParams + paramCount * s + 3]); 
    94       sizeT[s] = Integer.parseInt(args[leadParams + paramCount * s + 4]); 
    95       int len = sizeZ[s] * sizeC[s] * sizeT[s]; 
    96       dimOrder[s] = args[leadParams + paramCount * s + 5].toUpperCase(); 
    97       images[s] = new BufferedImage[len]; 
    98       if (s < numSeries - 1) offsets[s + 1] = offsets[s] + len; 
    99     } 
    100     int ndx = 0; 
     149 
     150    BufferedImage[][][] images = new BufferedImage[numImages][][]; 
     151    int[][] globalOffsets = new int[numImages][]; // IFD offsets across Images 
     152    int[][] localOffsets = new int[numImages][]; // IFD offsets per Image 
     153    int globalOffset = 0, localOffset = 0; 
     154    for (int i=0; i<numImages; i++) { 
     155      images[i] = new BufferedImage[numPixels[i]][]; 
     156      globalOffsets[i] = new int[numPixels[i]]; 
     157      localOffsets[i] = new int[numPixels[i]]; 
     158      localOffset = 0; 
     159      for (int p=0; p<numPixels[i]; p++) { 
     160        int len = sizeZ[i][p] * sizeC[i][p] * sizeT[i][p]; 
     161        images[i][p] = new BufferedImage[len]; 
     162        globalOffsets[i][p] = globalOffset; 
     163        globalOffset += len; 
     164        localOffsets[i][p] = localOffset; 
     165        localOffset += len; 
     166      } 
     167    } 
    101168 
    102169    System.out.println("Generating image planes"); 
    103     for (int s=0; s<numSeries; s++) { 
    104       int len = images[s].length; 
    105       System.out.print("\tSeries #" + (s + 1) + " - " + 
    106         sizeX[s] + " x " + sizeY[s] + ", " + 
    107         sizeZ[s] + "Z " + sizeC[s] + "C " + sizeT[s] + "T"); 
    108       for (int p=0; p<len; p++) { 
    109         int[] zct = FormatTools.getZCTCoords(dimOrder[s], 
    110           sizeZ[s], sizeC[s], sizeT[s], len, p); 
    111  
    112         System.out.print("."); 
    113         images[s][p] = new BufferedImage( 
    114           sizeX[s], sizeY[s], BufferedImage.TYPE_BYTE_GRAY); 
    115         Graphics2D g = images[s][p].createGraphics(); 
    116         // draw gradient 
    117         boolean even = s % 2 == 0; 
    118         int type = s / 2; 
    119         if (even) { 
    120           // draw vertical gradient for even-numbered series 
    121           for (int y=0; y<sizeY[s]; y++) { 
    122             int v = gradient(type, y, sizeY[s]); 
    123             g.setColor(new Color(v, v, v)); 
    124             g.drawLine(0, y, sizeX[s], y); 
    125           } 
     170    for (int i=0, ipNum=0; i<numImages; i++) { 
     171      System.out.println("  Image #" + (i + 1) + ":"); 
     172      for (int p=0; p<numPixels[i]; p++, ipNum++) { 
     173        System.out.print("    Pixels #" + (p + 1) + " - " + 
     174          sizeX[i][p] + " x " + sizeY[i][p] + ", " + 
     175          sizeZ[i][p] + "Z " + sizeC[i][p] + "C " + sizeT[i][p] + "T"); 
     176        int len = images[i][p].length; 
     177        for (int j=0; j<len; j++) { 
     178          int[] zct = FormatTools.getZCTCoords(dimOrder[i][p], 
     179            sizeZ[i][p], sizeC[i][p], sizeT[i][p], len, j); 
     180 
     181          System.out.print("."); 
     182          images[i][p][j] = new BufferedImage( 
     183            sizeX[i][p], sizeY[i][p], BufferedImage.TYPE_BYTE_GRAY); 
     184          Graphics2D g = images[i][p][j].createGraphics(); 
     185          // draw gradient 
     186          boolean even = ipNum % 2 == 0; 
     187          int type = ipNum / 2; 
     188          if (even) { 
     189            // draw vertical gradient for even-numbered pixelses 
     190            for (int y=0; y<sizeY[i][p]; y++) { 
     191              int v = gradient(type, y, sizeY[i][p]); 
     192              g.setColor(new Color(v, v, v)); 
     193              g.drawLine(0, y, sizeX[i][p], y); 
     194            } 
     195          } 
     196          else { 
     197            // draw horizontal gradient for odd-numbered pixelses 
     198            for (int x=0; x<sizeX[i][p]; x++) { 
     199              int v = gradient(type, x, sizeX[i][p]); 
     200              g.setColor(new Color(v, v, v)); 
     201              g.drawLine(x, 0, x, sizeY[i][p]); 
     202            } 
     203          } 
     204 
     205          // build list of text lines from planar information 
     206          Vector lines = new Vector(); 
     207          Font font = g.getFont(); 
     208          lines.add(new TextLine(name, font.deriveFont(32f), 5, -5)); 
     209          lines.add(new TextLine(sizeX[i][p] + " x " + sizeY[i][p], 
     210            font.deriveFont(Font.ITALIC, 16f), 20, 10)); 
     211          lines.add(new TextLine(dimOrder[i][p], 
     212            font.deriveFont(Font.ITALIC, 14f), 30, 5)); 
     213          int space = 5; 
     214          if (numImages > 1) { 
     215            lines.add(new TextLine("Image #" + (i + 1) + "/" + numImages, 
     216              font, 20, space)); 
     217            space = 2; 
     218          } 
     219          if (numPixels[i] > 1) { 
     220            lines.add(new TextLine("Pixels #" + (p + 1) + "/" + numPixels[i], 
     221              font, 20, space)); 
     222            space = 2; 
     223          } 
     224          if (sizeZ[i][p] > 1) { 
     225            lines.add(new TextLine("Focal plane = " + 
     226              (zct[0] + 1) + "/" + sizeZ[i][p], font, 20, space)); 
     227            space = 2; 
     228          } 
     229          if (sizeC[i][p] > 1) { 
     230            lines.add(new TextLine("Channel = " + 
     231              (zct[1] + 1) + "/" + sizeC[i][p], font, 20, space)); 
     232            space = 2; 
     233          } 
     234          if (sizeT[i][p] > 1) { 
     235            lines.add(new TextLine("Time point = " + 
     236              (zct[2] + 1) + "/" + sizeT[i][p], font, 20, space)); 
     237            space = 2; 
     238          } 
     239 
     240          // draw text lines to image 
     241          g.setColor(Color.white); 
     242          int yoff = 0; 
     243          for (int l=0; l<lines.size(); l++) { 
     244            TextLine text = (TextLine) lines.get(l); 
     245            g.setFont(text.font); 
     246            Rectangle2D r = g.getFont().getStringBounds( 
     247              text.line, g.getFontRenderContext()); 
     248            yoff += r.getHeight() + text.ypad; 
     249            g.drawString(text.line, text.xoff, yoff); 
     250          } 
     251          g.dispose(); 
    126252        } 
    127         else { 
    128           // draw horizontal gradient for odd-numbered series 
    129           for (int x=0; x<sizeX[s]; x++) { 
    130             int v = gradient(type, x, sizeX[s]); 
    131             g.setColor(new Color(v, v, v)); 
    132             g.drawLine(x, 0, x, sizeY[s]); 
    133           } 
    134         } 
    135  
    136         // build list of text lines from planar information 
    137         Vector lines = new Vector(); 
    138         Font font = g.getFont(); 
    139         lines.add(new TextLine(name, font.deriveFont(32f), 5, -5)); 
    140         lines.add(new TextLine(sizeX[s] + " x " + sizeY[s], 
    141           font.deriveFont(Font.ITALIC, 16f), 20, 10)); 
    142         lines.add(new TextLine(dimOrder[s], 
    143           font.deriveFont(Font.ITALIC, 14f), 30, 5)); 
    144         if (numSeries > 1) { 
    145           lines.add(new TextLine("Series #" + (s + 1) + "/" + numSeries, 
    146             font, 20, 5)); 
    147         } 
    148         if (sizeZ[s] > 1) { 
    149           lines.add(new TextLine( 
    150             "Focal plane = " + (zct[0] + 1) + "/" + sizeZ[s], font, 20, 2)); 
    151         } 
    152         if (sizeC[s] > 1) { 
    153           lines.add(new TextLine( 
    154             "Channel = " + (zct[1] + 1) + "/" + sizeC[s], font, 20, 2)); 
    155         } 
    156         if (sizeT[s] > 1) { 
    157           lines.add(new TextLine( 
    158             "Time point = " + (zct[2] + 1) + "/" + sizeT[s], font, 20, 2)); 
    159         } 
    160  
    161         // draw text lines to image 
    162         g.setColor(Color.white); 
    163         int yoff = 0; 
    164         for (int i=0; i<lines.size(); i++) { 
    165           TextLine text = (TextLine) lines.get(i); 
    166           g.setFont(text.font); 
    167           Rectangle2D r = g.getFont().getStringBounds( 
    168             text.line, g.getFontRenderContext()); 
    169           yoff += r.getHeight() + text.ypad; 
    170           g.drawString(text.line, text.xoff, yoff); 
    171         } 
    172         g.dispose(); 
    173       } 
    174       System.out.println(); 
     253        System.out.println(); 
     254      } 
    175255    } 
    176256 
    177257    System.out.println("Writing output files"); 
    178     boolean allS = dist.indexOf("s") >= 0; 
     258    boolean allI = dist.indexOf("i") >= 0; 
     259    boolean allP = dist.indexOf("p") >= 0; 
    179260    boolean allZ = dist.indexOf("z") >= 0; 
    180261    boolean allC = dist.indexOf("c") >= 0; 
     
    182263 
    183264    // determine filename for each image plane 
    184     String[][] filenames = new String[numSeries][]; 
     265    String[][][] filenames = new String[numImages][][]; 
    185266    Hashtable lastHash = new Hashtable(); 
    186     boolean[][] last = new boolean[numSeries][]; 
     267    boolean[][][] last = new boolean[numImages][][]; 
    187268    Hashtable firstZ = new Hashtable(); 
    188269    Hashtable firstC = new Hashtable(); 
    189270    Hashtable firstT = new Hashtable(); 
    190271    StringBuffer sb = new StringBuffer(); 
    191     for (int s=0; s<numSeries; s++) { 
    192       int len = images[s].length; 
    193       filenames[s] = new String[len]; 
    194       last[s] = new boolean[len]; 
    195       for (int p=0; p<len; p++) { 
    196         sb.append(name); 
    197         if (!allS && numSeries > 1) sb.append("_series" + (s + 1)); 
    198         int[] zct = FormatTools.getZCTCoords(dimOrder[s], 
    199           sizeZ[s], sizeC[s], sizeT[s], len, p); 
    200         if (!allZ && sizeZ[s] > 1) sb.append("_Z" + (zct[0] + 1)); 
    201         if (!allC && sizeC[s] > 1) sb.append("_C" + (zct[1] + 1)); 
    202         if (!allT && sizeT[s] > 1) sb.append("_T" + (zct[2] + 1)); 
    203         sb.append(".ome.tif"); 
    204         filenames[s][p] = sb.toString(); 
    205         sb.setLength(0); 
    206         last[s][p] = true; 
    207  
    208         // update last flag for this filename 
    209         String key = filenames[s][p]; 
    210         ImageIndex index = (ImageIndex) lastHash.get(key); 
    211         if (index != null) last[index.series][index.plane] = false; 
    212         lastHash.put(key, new ImageIndex(s, p)); 
    213  
    214         // update FirstZ, FirstC and FirstT values for this filename 
    215         if (!allZ && sizeZ[s] > 1) { 
    216           firstZ.put(filenames[s][p], new Integer(zct[0])); 
    217         } 
    218         if (!allC && sizeC[s] > 1) { 
    219           firstC.put(filenames[s][p], new Integer(zct[1])); 
    220         } 
    221         if (!allT && sizeT[s] > 1) { 
    222           firstT.put(filenames[s][p], new Integer(zct[2])); 
     272    for (int i=0; i<numImages; i++) { 
     273      filenames[i] = new String[numPixels[i]][]; 
     274      last[i] = new boolean[numPixels[i]][]; 
     275      for (int p=0; p<numPixels[i]; p++) { 
     276        int len = images[i][p].length; 
     277        filenames[i][p] = new String[len]; 
     278        last[i][p] = new boolean[len]; 
     279        for (int j=0; j<len; j++) { 
     280          sb.append(name); 
     281          if (!allI && numImages > 1) sb.append("_image" + (i + 1)); 
     282          if (!allP && numPixels[i] > 1) sb.append("_pixels" + (p + 1)); 
     283          int[] zct = FormatTools.getZCTCoords(dimOrder[i][p], 
     284            sizeZ[i][p], sizeC[i][p], sizeT[i][p], len, j); 
     285          if (!allZ && sizeZ[i][p] > 1) sb.append("_Z" + (zct[0] + 1)); 
     286          if (!allC && sizeC[i][p] > 1) sb.append("_C" + (zct[1] + 1)); 
     287          if (!allT && sizeT[i][p] > 1) sb.append("_T" + (zct[2] + 1)); 
     288          sb.append(".ome.tif"); 
     289          filenames[i][p][j] = sb.toString(); 
     290          sb.setLength(0); 
     291          last[i][p][j] = true; 
     292 
     293          // update last flag for this filename 
     294          String key = filenames[i][p][j]; 
     295          ImageIndex index = (ImageIndex) lastHash.get(key); 
     296          if (index != null) { 
     297            last[index.image][index.pixels][index.plane] = false; 
     298          } 
     299          lastHash.put(key, new ImageIndex(i, p, j)); 
     300 
     301          // update FirstZ, FirstC and FirstT values for this filename 
     302          if (!allZ && sizeZ[i][p] > 1) { 
     303            firstZ.put(filenames[i][p][j], new Integer(zct[0])); 
     304          } 
     305          if (!allC && sizeC[i][p] > 1) { 
     306            firstC.put(filenames[i][p][j], new Integer(zct[1])); 
     307          } 
     308          if (!allT && sizeT[i][p] > 1) { 
     309            firstT.put(filenames[i][p][j], new Integer(zct[2])); 
     310          } 
    223311        } 
    224312      } 
     
    266354      "xsi:schemaLocation=\"" + 
    267355      "http://www.openmicroscopy.org/XMLschemas/OME/FC/ome.xsd\">"); 
    268     for (int s=0; s<numSeries; s++) { 
     356    for (int i=0; i<numImages; i++) { 
    269357      sb.append("<Image " + 
    270         "ID=\"org.openmicroscopy:Image:" + (s + 1) + "\" " + 
     358        "ID=\"org.openmicroscopy:Image:" + (i + 1) + "\" " + 
    271359        "Name=\"" + name + "\" " + 
    272         "DefaultPixels=\"org.openmicroscopy:Pixels:" + (s + 1) + "\">" + 
    273         "<CreationDate>" + creationDate + "</CreationDate>" + 
    274         "<Pixels ID=\"Pixels:1\" " + 
    275         "DimensionOrder=\"" + dimOrder[s] + "\" " + 
    276         "PixelType=\"uint8\" " + 
    277         "BigEndian=\"true\" " + 
    278         "SizeX=\"" + sizeX[s] + "\" " + 
    279         "SizeY=\"" + sizeY[s] + "\" " + 
    280         "SizeZ=\"" + sizeZ[s] + "\" " + 
    281         "SizeC=\"" + sizeC[s] + "\" " + 
    282         "SizeT=\"" + sizeT[s] + "\">" + 
    283         "TIFF_DATA_SERIES_" + s + // placeholder 
    284         "</Pixels></Image>"); 
     360        "DefaultPixels=\"org.openmicroscopy:Pixels:" + (i + 1) + "-1\">" + 
     361        "<CreationDate>" + creationDate + "</CreationDate>"); 
     362      for (int p=0; p<numPixels[i]; p++) { 
     363        sb.append("<Pixels " + 
     364          "ID=\"org.openmicroscopy.Pixels:" + (i + 1) + "-" + (p + 1) + "\" " + 
     365          "DimensionOrder=\"" + dimOrder[i][p] + "\" " + 
     366          "PixelType=\"uint8\" " + 
     367          "BigEndian=\"true\" " + 
     368          "SizeX=\"" + sizeX[i][p] + "\" " + 
     369          "SizeY=\"" + sizeY[i][p] + "\" " + 
     370          "SizeZ=\"" + sizeZ[i][p] + "\" " + 
     371          "SizeC=\"" + sizeC[i][p] + "\" " + 
     372          "SizeT=\"" + sizeT[i][p] + "\">" + 
     373          "TIFF_DATA_IMAGE_" + i + "_PIXELS_" + p + // placeholder 
     374          "</Pixels>"); 
     375      } 
     376      sb.append("</Image>"); 
    285377    } 
    286378    sb.append("</OME>"); 
     
    288380 
    289381    TiffWriter out = new TiffWriter(); 
    290     for (int s=0; s<numSeries; s++) { 
    291       int len = images[s].length; 
    292       System.out.println("\tSeries #" + (s + 1) + " - " + 
    293         sizeX[s] + " x " + sizeY[s] + ", " + 
    294         sizeZ[s] + "Z " + sizeC[s] + "C " + sizeT[s] + "T:"); 
    295       for (int p=0; p<len; p++) { 
    296         int[] zct = FormatTools.getZCTCoords(dimOrder[s], 
    297           sizeZ[s], sizeC[s], sizeT[s], len, p); 
    298         System.out.println("\t\tZ" + zct[0] + " C" + zct[1] + 
    299           " T" + zct[2] + " -> " + filenames[s][p] + (last[s][p] ? "*" : "")); 
    300         out.setId(filenames[s][p]); 
    301         // write comment stub, to be overwritten later 
    302         Hashtable ifd = new Hashtable(); 
    303         TiffTools.putIFDValue(ifd, TiffTools.IMAGE_DESCRIPTION, ""); 
    304         out.saveImage(images[s][p], ifd, last[s][p]); 
    305         if (last[s][p]) { 
    306           // append OME-XML block 
    307           String xml = xmlTemplate; 
    308           for (int ss=0; ss<numSeries; ss++) { 
    309             String pattern = "TIFF_DATA_SERIES_" + ss; 
    310             if (allS) { 
    311               xml = xml.replaceFirst(pattern, 
    312                 "<TiffData IFD=\"" + offsets[ss] + "\" " + 
    313                 "NumPlanes=\"" + images[ss].length + "\"/>"); 
     382    for (int i=0; i<numImages; i++) { 
     383        System.out.println("  Image #" + (i + 1) + ":"); 
     384      for (int p=0; p<numPixels[i]; p++) { 
     385        System.out.println("    Pixels #" + (p + 1) + " - " + 
     386          sizeX[i][p] + " x " + sizeY[i][p] + ", " + 
     387          sizeZ[i][p] + "Z " + sizeC[i][p] + "C " + sizeT[i][p] + "T:"); 
     388        int len = images[i][p].length; 
     389        for (int j=0; j<len; j++) { 
     390          int[] zct = FormatTools.getZCTCoords(dimOrder[i][p], 
     391            sizeZ[i][p], sizeC[i][p], sizeT[i][p], len, j); 
     392          System.out.println("      " + 
     393            "Z" + zct[0] + " C" + zct[1] + " T" + zct[2] + 
     394            " -> " + filenames[i][p][j] + (last[i][p][j] ? "*" : "")); 
     395          out.setId(filenames[i][p][j]); 
     396          // write comment stub, to be overwritten later 
     397          Hashtable ifd = new Hashtable(); 
     398          TiffTools.putIFDValue(ifd, TiffTools.IMAGE_DESCRIPTION, ""); 
     399          out.saveImage(images[i][p][j], ifd, last[i][p][j]); 
     400          if (last[i][p][j]) { 
     401            // append OME-XML block 
     402            String xml = xmlTemplate; 
     403            for (int ii=0; ii<numImages; ii++) { 
     404              for (int pp=0; pp<numPixels[ii]; pp++) { 
     405                String pattern = "TIFF_DATA_IMAGE_" + ii + "_PIXELS_" + pp; 
     406                if (allP) { 
     407                  xml = xml.replaceFirst(pattern, 
     408                    "<TiffData IFD=\"" + globalOffsets[ii][pp] + "\" " + 
     409                    "NumPlanes=\"" + images[ii][pp].length + "\"/>"); 
     410                } 
     411                else if (p == pp) { 
     412                  if (allI) { 
     413                    xml = xml.replaceFirst(pattern, 
     414                      "<TiffData IFD=\"" + localOffsets[ii][pp] + "\" " + 
     415                      "NumPlanes=\"" + images[ii][p].length + "\"/>"); 
     416                  } 
     417                  else { 
     418                    Integer fz = (Integer) firstZ.get(filenames[i][p][j]); 
     419                    Integer fc = (Integer) firstC.get(filenames[i][p][j]); 
     420                    Integer ft = (Integer) firstT.get(filenames[i][p][j]); 
     421                    sb.setLength(0); 
     422                    sb.append("<TiffData"); 
     423                    if (fz != null) sb.append(" FirstZ=\"" + fz + "\""); 
     424                    if (fc != null) sb.append(" FirstC=\"" + fc + "\""); 
     425                    if (ft != null) sb.append(" FirstT=\"" + ft + "\""); 
     426                    sb.append("/>"); 
     427                    xml = xml.replaceFirst(pattern, sb.toString()); 
     428                  } 
     429                } 
     430                else { 
     431                  xml = xml.replaceFirst(pattern, 
     432                    "<TiffData NumPlanes=\"0\"/>"); 
     433                } 
     434              } 
    314435            } 
    315             else if (s == ss) { 
    316               Integer fz = (Integer) firstZ.get(filenames[s][p]); 
    317               Integer fc = (Integer) firstC.get(filenames[s][p]); 
    318               Integer ft = (Integer) firstT.get(filenames[s][p]); 
    319               sb.setLength(0); 
    320               sb.append("<TiffData"); 
    321               if (fz != null) sb.append(" FirstZ=\"" + fz + "\""); 
    322               if (fc != null) sb.append(" FirstC=\"" + fc + "\""); 
    323               if (ft != null) sb.append(" FirstT=\"" + ft + "\""); 
    324               sb.append("/>"); 
    325               xml = xml.replaceFirst(pattern, sb.toString()); 
    326             } 
    327             else { 
    328               xml = xml.replaceFirst(pattern, "<TiffData NumPlanes=\"0\"/>"); 
    329             } 
    330           } 
    331           TiffTools.overwriteComment(filenames[s][p], xml); 
     436            TiffTools.overwriteComment(filenames[i][p][j], xml); 
     437          } 
    332438        } 
    333439      } 
     
    349455 
    350456  private static class ImageIndex { 
    351     private int series; 
     457    private int image; 
     458    private int pixels; 
    352459    private int plane; 
    353     private ImageIndex(int series, int plane) { 
    354       this.series = series; 
    355       this.plane = plane; 
     460    private ImageIndex(int i, int p, int j) { 
     461      this.image = i; 
     462      this.pixels = p; 
     463      this.plane = j; 
    356464    } 
    357465  } 
Note: See TracChangeset for help on using the changeset viewer.