Changeset 1834


Ignore:
Timestamp:
11/21/06 08:25:14 (13 years ago)
Author:
melissa
Message:
  • Force importer to make all images in a stack the same size.
  • Fixed bug in ND2 reader.
  • Fixed bug in BaseTiffReader (openBytes assumed RGB).
  • Fixed bug in MetamorphReader that caused some files to open slowly.
  • Fixed bugs in ImageTools.padImage() and ImageTools.make24Bits()
  • Added command-line option "-fast" that converts RGB images to 24-bit RGB. This may or may not be useful.
Location:
trunk/loci
Files:
7 edited

Legend:

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

    r1812 r1834  
    119119 
    120120      byte[] sourceBytes = reader.openBytes(id, source); 
     121      sourceBytes = ImageTools.padImage(sourceBytes, isInterleaved(id), c, 
     122        reader.openImage(id, source).getWidth(), getSizeX(id), getSizeY(id)); 
    121123      return ImageTools.splitChannels(sourceBytes, c, 
    122124        false, isInterleaved(id))[channel]; 
  • trunk/loci/formats/FormatReader.java

    r1812 r1834  
    469469    boolean ignoreColors = false; 
    470470    boolean normalize = false; 
     471    boolean fastBlit = false; 
    471472    int start = 0; 
    472473    int end = 0; 
     
    485486          else if (args[i].equals("-omexml")) omexml = true; 
    486487          else if (args[i].equals("-normalize")) normalize = true; 
     488          else if (args[i].equals("-fast")) fastBlit = true; 
    487489          else if (args[i].equals("-range")) { 
    488490            try { 
     
    672674      boolean mismatch = false; 
    673675      for (int i=start; i<end; i++) { 
    674         images[i - start] = thumbs ? 
    675           reader.openThumbImage(id, i) : reader.openImage(id, i); 
     676        if (!fastBlit) { 
     677          images[i - start] = thumbs ? 
     678            reader.openThumbImage(id, i) : reader.openImage(id, i); 
     679        } 
     680        else { 
     681          int x = reader.getSizeX(id); 
     682          int y = reader.getSizeY(id); 
     683          byte[] b = thumbs ? reader.openThumbBytes(id, i) :  
     684            reader.openBytes(id, i); 
     685          Object pix = DataTools.makeDataArray(b,  
     686            FormatReader.getBytesPerPixel(reader.getPixelType(id)), 
     687            reader.getPixelType(id) == FormatReader.FLOAT,  
     688            reader.isLittleEndian(id)); 
     689          images[i - start] =  
     690            ImageTools.makeImage(ImageTools.make24Bits(pix, x, y,  
     691              reader.isInterleaved(id), false), x, y); 
     692        } 
    676693 
    677694        // check for pixel type mismatch 
    678695        int pixType = ImageTools.getPixelType(images[i - start]); 
    679         if (pixType != pixelType) { 
     696        if (pixType != pixelType && !fastBlit) { 
    680697          if (!mismatch) { 
    681698            System.out.println(); 
  • trunk/loci/formats/ImageTools.java

    r1806 r1834  
    914914  /** 
    915915   * Convert an arbitrary primitive type array with 3 samples per pixel to 
     916   * a 3 x (width * height) byte array. 
     917   */ 
     918  public static byte[][] make24Bits(Object pixels, int w, int h, 
     919    boolean interleaved, boolean reverse) 
     920  { 
     921    int[] pix = make24Bits(pixels, w, h, interleaved); 
     922    byte[][] rtn = new byte[3][pix.length]; 
     923    for (int i=0; i<pix.length; i++) { 
     924      byte r = (byte) ((pix[i] >> 16) & 0xff); 
     925      rtn[1][i] = (byte) ((pix[i] >> 8) & 0xff); 
     926      byte b = (byte) (pix[i] & 0xff); 
     927      rtn[0][i] = reverse ? b : r; 
     928      rtn[2][i] = reverse ? r : b; 
     929    } 
     930    return rtn; 
     931  } 
     932 
     933 
     934  /** 
     935   * Convert an arbitrary primitive type array with 3 samples per pixel to 
    916936   * an int array, i.e. RGB color with 8 bits per pixel. 
    917937   * Does not perform any scaling. 
     
    922942    int[] rtn = new int[w * h]; 
    923943    int stride = interleaved ? w * h : 1; 
    924     int mul = interleaved ? 1 : 3; 
    925     if (pixels instanceof byte[]) { 
    926       byte[] b = (byte[]) pixels; 
    927       for (int i=0; i<rtn.length; i++) { 
    928         byte[] a = new byte[] {0, b[i*mul], b[i*mul + stride], 
    929           b[i*mul + 2*stride]}; 
    930         rtn[i] = DataTools.bytesToInt(a, false); 
    931       } 
    932       b = null; 
    933     } 
     944     
     945    byte[] b = null; 
     946 
     947    if (pixels instanceof byte[]) b = (byte[]) pixels; 
    934948    else if (pixels instanceof short[]) { 
    935949      short[] s = (short[]) pixels; 
    936       for (int i=0; i<rtn.length; i++) { 
    937         byte[] a = new byte[] {0, (byte) s[i*mul], (byte) s[i*mul + stride], 
    938           (byte) s[i*mul + 2*stride]}; 
    939         rtn[i] = DataTools.bytesToInt(a, false); 
    940       } 
    941       s = null; 
     950      b = new byte[s.length]; 
     951      for (int i=0; i<s.length; i++) b[i] = (byte) ((255 * s[i]) / 65535); 
    942952    } 
    943953    else if (pixels instanceof int[]) { 
    944       int[] in = (int[]) pixels; 
    945       for (int i=0; i<rtn.length; i++) { 
    946         byte[] a = new byte[] {0, (byte) in[i*mul], (byte) in[i*mul + stride], 
    947           (byte) in[i*mul + 2*stride]}; 
    948         rtn[i] = DataTools.bytesToInt(a, false); 
    949       } 
    950       in = null; 
     954      int[] s = (int[]) pixels; 
     955      b = new byte[s.length]; 
     956      for (int i=0; i<s.length; i++) b[i] = (byte) ((255 * s[i]) / 4294967295L); 
    951957    } 
    952958    else if (pixels instanceof float[]) { 
    953       float[] f = (float[]) pixels; 
    954       for (int i=0; i<rtn.length; i++) { 
    955         byte[] a = new byte[] { 
    956           0, (byte) Float.floatToIntBits(f[i*mul]), 
    957           (byte) Float.floatToIntBits(f[i*mul + stride]), 
    958           (byte) Float.floatToIntBits(f[i*mul + 2*stride])}; 
    959         rtn[i] = DataTools.bytesToInt(a, false); 
    960       } 
    961       f = null; 
     959      float[] s = (float[]) pixels; 
     960      b = new byte[s.length]; 
     961      for (int i=0; i<s.length; i++) { 
     962        b[i] = (byte) ((255 * Float.floatToIntBits(s[i])) / 4294967295L); 
     963      } 
    962964    } 
    963965    else if (pixels instanceof double[]) { 
    964       double[] d = (double[]) pixels; 
    965       for (int i=0; i<rtn.length; i++) { 
    966         byte[] a = new byte[] { 
    967           0, (byte) Double.doubleToLongBits(d[i*mul]), 
    968           (byte) Double.doubleToLongBits(d[i*mul + stride]), 
    969           (byte) Double.doubleToLongBits(d[i*mul + 2*stride])}; 
    970         rtn[i] = DataTools.bytesToInt(a, false); 
    971       } 
    972       d = null; 
    973     } 
     966      double[] s = (double[]) pixels; 
     967      b = new byte[s.length]; 
     968      for (int i=0; i<s.length; i++) { 
     969        b[i] = (byte) ((255 * Double.doubleToLongBits(s[i])) / 8589934590L); 
     970      } 
     971    } 
     972     
     973    int c = b.length / rtn.length; 
     974 
     975    for (int i=0; i<rtn.length; i++) { 
     976      byte[] a = new byte[4]; 
     977      for (int j=c-1; j>=0; j--) { 
     978        a[j] = b[interleaved ? i*c + j : i + j*w*h]; 
     979      } 
     980      rtn[i] = DataTools.bytesToInt(a, true); 
     981    } 
     982     
    974983    return rtn; 
    975984  } 
     
    11961205        short[][] newShorts = new short[b.length][width * height]; 
    11971206        for (int i=0; i<b.length; i++) { 
    1198           newShorts[i] = padImage(b[i], 1, img.getWidth(), width, height); 
     1207          newShorts[i] =  
     1208            padImage(b[i], false, 1, img.getWidth(), width, height); 
    11991209        } 
    12001210        return makeImage(newShorts, width, height); 
     
    12041214        int[][] newInts = new int[b.length][width * height]; 
    12051215        for (int i=0; i<b.length; i++) { 
    1206           newInts[i] = padImage(b[i], 1, img.getWidth(), width, height); 
     1216          newInts[i] = padImage(b[i], false, 1, img.getWidth(), width, height); 
    12071217        } 
    12081218        return makeImage(newInts, width, height); 
     
    12121222        float[][] newFloats = new float[b.length][width * height]; 
    12131223        for (int i=0; i<b.length; i++) { 
    1214           newFloats[i] = padImage(b[i], 1, img.getWidth(), width, height); 
     1224          newFloats[i] =  
     1225            padImage(b[i], false, 1, img.getWidth(), width, height); 
    12151226        } 
    12161227        return makeImage(newFloats, width, height); 
     
    12201231        double[][] newDoubles = new double[b.length][width * height]; 
    12211232        for (int i=0; i<b.length; i++) { 
    1222           newDoubles[i] = padImage(b[i], 1, img.getWidth(), width, height); 
     1233          newDoubles[i] =  
     1234            padImage(b[i], false, 1, img.getWidth(), width, height); 
    12231235        } 
    12241236        return makeImage(newDoubles, width, height); 
     
    12401252 
    12411253    if (needsPadding) { 
    1242       int totalX = width - oldWidth; 
    1243       int totalY = height - (b.length / oldWidth); 
    1244  
    1245       int xpad = totalX / 2; 
    1246       int ypad = totalY / 2; 
    1247  
    1248       if (xpad == 0 && totalX > 0) xpad = totalX; 
    1249       if (ypad == 0 && totalY > 0) ypad = totalY; 
    1250  
    1251       byte[] padded = new byte[width * height * c]; 
    1252  
    1253       int n = 0; 
    1254       if (ypad * 2 != totalY) n = 1; 
    1255  
    1256       if (totalY < 0) { 
    1257         ypad = 0; 
    1258         n = 0; 
    1259       } 
    1260  
    1261       if (totalX < 0) xpad = 0; 
    1262  
    1263       if (interleaved) { 
    1264         int src = 0; 
    1265         int dest = ypad * width * c + xpad * c; 
    1266  
    1267         for (int i=ypad; i<height - ypad - n; i++) { 
    1268           int len = width < oldWidth ? width * c : oldWidth * c; 
    1269           System.arraycopy(b, src, padded, dest, len); 
    1270           src += oldWidth * c; 
    1271           dest += width * c; 
    1272         } 
    1273       } 
    1274  
    1275       return padded; 
    1276     } 
    1277     return b; 
     1254      int oldHeight = b.length / (oldWidth * c); 
     1255 
     1256      // adjust to correct width 
     1257 
     1258      byte[] padded = new byte[width * oldHeight * c]; 
     1259      int clip = (width - oldWidth) / 2; 
     1260 
     1261      for (int i=0; i<oldHeight; i++) { 
     1262        System.arraycopy(b, i*oldWidth*c, padded, i*width*c,  
     1263          clip < 0 ? width*c : oldWidth*c); 
     1264      } 
     1265 
     1266      // adjust to correct height 
     1267 
     1268      byte[] rtn = new byte[width * height * c]; 
     1269      clip = (height - oldHeight) / 2; 
     1270 
     1271      if (clip < 0) { 
     1272        clip *= -1; 
     1273        for (int i=0; i<height; i++) { 
     1274          System.arraycopy(padded, (i+clip)*width*c, rtn, i*width*c, width*c); 
     1275        } 
     1276      } 
     1277      else { 
     1278        for (int i=clip; i<height+clip; i++) { 
     1279          System.arraycopy(padded, i*width*c, rtn, (i-clip)*width*c, width*c); 
     1280        } 
     1281      } 
     1282      return rtn; 
     1283    } 
     1284    return b;  
    12781285  } 
    12791286 
     
    12821289   * centered within the new bounds. 
    12831290   */ 
    1284   public static short[] padImage(short[] b, int c, int oldWidth, 
    1285     int width, int height) 
    1286   { 
    1287     boolean needsPadding = oldWidth != width || (b.length / oldWidth) != height; 
     1291  public static short[] padImage(short[] b, boolean interleaved, int c,  
     1292    int oldWidth, int width, int height) 
     1293  { 
     1294    boolean needsPadding = 
     1295      (oldWidth != width) || ((b.length / (oldWidth*c)) != height); 
    12881296 
    12891297    if (needsPadding) { 
    1290       int totalX = width - oldWidth; 
    1291       int totalY = height - (b.length / oldWidth); 
    1292  
    1293       int xpad = totalX / 2; 
    1294       int ypad = totalY / 2; 
    1295  
    1296       if (xpad == 0 && totalX > 0) xpad = totalX; 
    1297       if (ypad == 0 && totalY > 0) ypad = totalY; 
    1298  
    1299       short[] padded = new short[width * height]; 
    1300  
    1301       int n = 0; 
    1302       if (ypad * 2 != totalY) n = 1; 
    1303  
    1304       if (totalY < 0) { 
    1305         ypad = 0; 
    1306         n = 0; 
    1307       } 
    1308  
    1309       for (int i=ypad; i<height - ypad - n; i++) { 
    1310         System.arraycopy(b, (i - ypad) * oldWidth, padded, i*width + xpad, 
    1311           oldWidth); 
    1312       } 
    1313       return padded; 
    1314     } 
    1315     return b; 
     1298      int oldHeight = b.length / (oldWidth * c); 
     1299 
     1300      // adjust to correct width 
     1301 
     1302      short[] padded = new short[width * oldHeight * c]; 
     1303      int clip = (width - oldWidth) / 2; 
     1304 
     1305      for (int i=0; i<oldHeight; i++) { 
     1306        System.arraycopy(b, i*oldWidth*c, padded, i*width*c,  
     1307          clip < 0 ? width*c : oldWidth*c); 
     1308      } 
     1309 
     1310      // adjust to correct height 
     1311 
     1312      short[] rtn = new short[width * height * c]; 
     1313      clip = (height - oldHeight) / 2; 
     1314 
     1315      if (clip < 0) { 
     1316        clip *= -1; 
     1317        for (int i=0; i<height; i++) { 
     1318          System.arraycopy(padded, (i+clip)*width*c, rtn, i*width*c, width*c); 
     1319        } 
     1320      } 
     1321      else { 
     1322        for (int i=clip; i<height+clip; i++) { 
     1323          System.arraycopy(padded, i*width*c, rtn, (i-clip)*width*c, width*c); 
     1324        } 
     1325      } 
     1326      return rtn; 
     1327    } 
     1328    return b;  
    13161329  } 
    13171330 
     
    13201333   * centered within the new bounds. 
    13211334   */ 
    1322   public static int[] padImage(int[] b, int c, int oldWidth, 
    1323     int width, int height) 
    1324   { 
    1325     boolean needsPadding = oldWidth != width || (b.length / oldWidth) != height; 
     1335  public static int[] padImage(int[] b, boolean interleaved, int c,  
     1336    int oldWidth, int width, int height) 
     1337  { 
     1338    boolean needsPadding = 
     1339      (oldWidth != width) || ((b.length / (oldWidth*c)) != height); 
    13261340 
    13271341    if (needsPadding) { 
    1328       int totalX = width - oldWidth; 
    1329       int totalY = height - (b.length / oldWidth); 
    1330  
    1331       int xpad = totalX / 2; 
    1332       int ypad = totalY / 2; 
    1333  
    1334       if (xpad == 0 && totalX > 0) xpad = totalX; 
    1335       if (ypad == 0 && totalY > 0) ypad = totalY; 
    1336  
    1337       int[] padded = new int[width * height]; 
    1338  
    1339       int n = 0; 
    1340       if (ypad * 2 != totalY) n = 1; 
    1341  
    1342       if (totalY < 0) { 
    1343         ypad = 0; 
    1344         n = 0; 
    1345       } 
    1346  
    1347       for (int i=ypad; i<height - ypad - n; i++) { 
    1348         System.arraycopy(b, (i - ypad) * oldWidth, padded, i*width + xpad, 
    1349           oldWidth); 
    1350       } 
    1351       return padded; 
    1352     } 
    1353     return b; 
     1342      int oldHeight = b.length / (oldWidth * c); 
     1343 
     1344      // adjust to correct width 
     1345 
     1346      int[] padded = new int[width * oldHeight * c]; 
     1347      int clip = (width - oldWidth) / 2; 
     1348 
     1349      for (int i=0; i<oldHeight; i++) { 
     1350        System.arraycopy(b, i*oldWidth*c, padded, i*width*c,  
     1351          clip < 0 ? width*c : oldWidth*c); 
     1352      } 
     1353 
     1354      // adjust to correct height 
     1355 
     1356      int[] rtn = new int[width * height * c]; 
     1357      clip = (height - oldHeight) / 2; 
     1358 
     1359      if (clip < 0) { 
     1360        clip *= -1; 
     1361        for (int i=0; i<height; i++) { 
     1362          System.arraycopy(padded, (i+clip)*width*c, rtn, i*width*c, width*c); 
     1363        } 
     1364      } 
     1365      else { 
     1366        for (int i=clip; i<height+clip; i++) { 
     1367          System.arraycopy(padded, i*width*c, rtn, (i-clip)*width*c, width*c); 
     1368        } 
     1369      } 
     1370      return rtn; 
     1371    } 
     1372    return b;  
    13541373  } 
    13551374 
     
    13581377   * centered within the new bounds. 
    13591378   */ 
    1360   public static float[] padImage(float[] b, int c, int oldWidth, 
    1361     int width, int height) 
    1362   { 
    1363     boolean needsPadding = oldWidth != width || (b.length / oldWidth) != height; 
     1379  public static float[] padImage(float[] b, boolean interleaved, int c,  
     1380    int oldWidth, int width, int height) 
     1381  { 
     1382    boolean needsPadding = 
     1383      (oldWidth != width) || ((b.length / (oldWidth*c)) != height); 
    13641384 
    13651385    if (needsPadding) { 
    1366       int totalX = width - oldWidth; 
    1367       int totalY = height - (b.length / oldWidth); 
    1368  
    1369       int xpad = totalX / 2; 
    1370       int ypad = totalY / 2; 
    1371  
    1372       if (xpad == 0 && totalX > 0) xpad = totalX; 
    1373       if (ypad == 0 && totalY > 0) ypad = totalY; 
    1374  
    1375       float[] padded = new float[width * height]; 
    1376  
    1377       int n = 0; 
    1378       if (ypad * 2 != totalY) n = 1; 
    1379  
    1380       if (totalY < 0) { 
    1381         ypad = 0; 
    1382         n = 0; 
    1383       } 
    1384  
    1385       for (int i=ypad; i<height - ypad - n; i++) { 
    1386         System.arraycopy(b, (i - ypad) * oldWidth, padded, i*width + xpad, 
    1387           oldWidth); 
    1388       } 
    1389       return padded; 
    1390     } 
    1391     return b; 
     1386      int oldHeight = b.length / (oldWidth * c); 
     1387 
     1388      // adjust to correct width 
     1389 
     1390      float[] padded = new float[width * oldHeight * c]; 
     1391      int clip = (width - oldWidth) / 2; 
     1392 
     1393      for (int i=0; i<oldHeight; i++) { 
     1394        System.arraycopy(b, i*oldWidth*c, padded, i*width*c,  
     1395          clip < 0 ? width*c : oldWidth*c); 
     1396      } 
     1397 
     1398      // adjust to correct height 
     1399 
     1400      float[] rtn = new float[width * height * c]; 
     1401      clip = (height - oldHeight) / 2; 
     1402 
     1403      if (clip < 0) { 
     1404        clip *= -1; 
     1405        for (int i=0; i<height; i++) { 
     1406          System.arraycopy(padded, (i+clip)*width*c, rtn, i*width*c, width*c); 
     1407        } 
     1408      } 
     1409      else { 
     1410        for (int i=clip; i<height+clip; i++) { 
     1411          System.arraycopy(padded, i*width*c, rtn, (i-clip)*width*c, width*c); 
     1412        } 
     1413      } 
     1414      return rtn; 
     1415    } 
     1416    return b;  
    13921417  } 
    13931418 
     
    13961421   * centered within the new bounds. 
    13971422   */ 
    1398   public static double[] padImage(double[] b, int c, int oldWidth, int width, 
    1399     int height) 
    1400   { 
    1401     boolean needsPadding = oldWidth != width || (b.length / oldWidth) != height; 
     1423  public static double[] padImage(double[] b, boolean interleaved, int c,  
     1424    int oldWidth, int width, int height) 
     1425  { 
     1426    boolean needsPadding = 
     1427      (oldWidth != width) || ((b.length / (oldWidth*c)) != height); 
    14021428 
    14031429    if (needsPadding) { 
    1404       int totalX = width - oldWidth; 
    1405       int totalY = height - (b.length / oldWidth); 
    1406  
    1407       int xpad = totalX / 2; 
    1408       int ypad = totalY / 2; 
    1409  
    1410       if (xpad == 0 && totalX > 0) xpad = totalX; 
    1411       if (ypad == 0 && totalY > 0) ypad = totalY; 
    1412  
    1413       double[] padded = new double[width * height]; 
    1414  
    1415       int n = 0; 
    1416       if (ypad * 2 != totalY) n = 1; 
    1417  
    1418       if (totalY < 0) { 
    1419         ypad = 0; 
    1420         n = 0; 
    1421       } 
    1422  
    1423       for (int i=ypad; i<height - ypad - n; i++) { 
    1424         System.arraycopy(b, (i - ypad) * oldWidth, padded, i*width + xpad, 
    1425           oldWidth); 
    1426       } 
    1427       return padded; 
    1428     } 
    1429     return b; 
     1430      int oldHeight = b.length / (oldWidth * c); 
     1431 
     1432      // adjust to correct width 
     1433 
     1434      double[] padded = new double[width * oldHeight * c]; 
     1435      int clip = (width - oldWidth) / 2; 
     1436 
     1437      for (int i=0; i<oldHeight; i++) { 
     1438        System.arraycopy(b, i*oldWidth*c, padded, i*width*c,  
     1439          clip < 0 ? width*c : oldWidth*c); 
     1440      } 
     1441 
     1442      // adjust to correct height 
     1443 
     1444      double[] rtn = new double[width * height * c]; 
     1445      clip = (height - oldHeight) / 2; 
     1446 
     1447      if (clip < 0) { 
     1448        clip *= -1; 
     1449        for (int i=0; i<height; i++) { 
     1450          System.arraycopy(padded, (i+clip)*width*c, rtn, i*width*c, width*c); 
     1451        } 
     1452      } 
     1453      else { 
     1454        for (int i=clip; i<height+clip; i++) { 
     1455          System.arraycopy(padded, i*width*c, rtn, (i-clip)*width*c, width*c); 
     1456        } 
     1457      } 
     1458      return rtn; 
     1459    } 
     1460    return b;  
    14301461  } 
    14311462 
  • trunk/loci/formats/in/BaseTiffReader.java

    r1825 r1834  
    762762 
    763763    int bytesPerPixel = FormatReader.getBytesPerPixel(getPixelType(id)); 
    764     byte[] buf = new byte[getSizeX(id) * getSizeY(id) * getSizeC(id) * 
    765       bytesPerPixel]; 
     764    byte[] buf = null; 
     765    if (isRGB(id)) { 
     766      buf =  
     767        new byte[getSizeX(id) * getSizeY(id) * getSizeC(id) * bytesPerPixel]; 
     768    } 
     769    else buf = new byte[getSizeX(id) * getSizeY(id) * bytesPerPixel]; 
     770 
    766771    return openBytes(id, no, buf); 
    767772  } 
  • trunk/loci/formats/in/MetamorphReader.java

    r1806 r1834  
    130130              StringBuffer sb = new StringBuffer(); 
    131131              char c = (char) in.read(); 
    132               while (c != 0 || sb.length() < 256) { 
     132              while (c != 0 || sb.length() < 128) { 
    133133                sb = sb.append(c); 
    134134                c = (char) in.read(); 
  • trunk/loci/formats/in/ND2Reader.java

    r1808 r1834  
    283283    numImages = offsets.length; 
    284284 
     285    pixelType[0] = FormatReader.UINT8; 
    285286    BufferedImage img = openImage(id, 0); 
    286287 
  • trunk/loci/plugins/Importer.java

    r1816 r1834  
    378378          int type = r.getPixelType(id); 
    379379 
    380           // TODO : pad the byte array to the appropriate size 
    381  
    382  
    383380          // construct image processor and add to stack 
    384381 
     
    397394          } 
    398395 
     396          if (b.length != w * h * c * bpp) { 
     397            BufferedImage bi = r.openImage(id, j); 
     398            b = ImageTools.padImage(b, r.isInterleaved(id), c, bi.getWidth()*bpp, 
     399              w, h); 
     400          } 
     401           
    399402          Object pixels = DataTools.makeDataArray(b, bpp, 
    400403            type == FormatReader.FLOAT || type == FormatReader.DOUBLE, 
Note: See TracChangeset for help on using the changeset viewer.