Changeset 1868


Ignore:
Timestamp:
11/29/06 08:56:20 (13 years ago)
Author:
melissa
Message:
  • Fixed bug in ImageTools.padImage methods (respect 'interleaved' flag)
  • Fixed FileStitcher.setColorTableIgnored
  • Fixed BaseTiffReader to respect value of isColorTableIgnored()
  • Removed calls to ImageTools.padImage(*) from ImageViewer and ChannelSeparator
Location:
trunk/loci/formats
Files:
5 edited

Legend:

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

    r1838 r1868  
    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)); 
    123121      return ImageTools.splitChannels(sourceBytes, c, 
    124122        false, isInterleaved(id))[channel]; 
  • trunk/loci/formats/FileStitcher.java

    r1833 r1868  
    433433  public void setColorTableIgnored(boolean ignore) { 
    434434    ignoreColorTable = ignore; 
     435    reader.setColorTableIgnored(ignore); 
     436    if (readers != null) { 
     437      for (int i=0; i<readers.length; i++) { 
     438        readers[i].setColorTableIgnored(ignore); 
     439      } 
     440    } 
    435441  } 
    436442 
  • trunk/loci/formats/ImageTools.java

    r1850 r1868  
    12621262  { 
    12631263    int oldHeight = b.length / (oldWidth * c); 
    1264     if (width < oldWidth) width = oldWidth; 
    1265     if (height < oldHeight) height = oldHeight; 
    1266     if (width == oldWidth && height == oldHeight) return b; 
     1264    byte[] padded = new byte[height * width * c]; 
    12671265 
    12681266    int wClip = (width - oldWidth) / 2; 
    12691267    int hClip = (height - oldHeight) / 2; 
    12701268 
    1271     byte[] padded = new byte[width * height * c]; 
    1272  
    1273     for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
    1274       int oldIndex = oldWidth * c * oy; 
    1275       int index = width * c * (y + hClip) + c * wClip; 
    1276       System.arraycopy(b, oldIndex, padded, index, oldWidth * c); 
    1277     } 
    1278  
     1269    int h = height < oldHeight ? height : oldHeight; 
     1270    
     1271    if (interleaved) { 
     1272      int len = oldWidth < width ? oldWidth : width; 
     1273      if (h == oldHeight) { 
     1274        for (int y=0; y<h*c; y++) { 
     1275          int oldIndex = oldWidth * y; 
     1276          int index = width * y; 
     1277          System.arraycopy(b, oldIndex, padded, index, len); 
     1278        } 
     1279      } 
     1280      else { 
     1281        for (int ch=0; ch<c; ch++) { 
     1282          for (int y=0; y<h; y++) { 
     1283            int oldIndex = oldWidth * ch * oldHeight + oldWidth * y; 
     1284            int index = width * ch * height + width * y; 
     1285            System.arraycopy(b, oldIndex, padded, index, len); 
     1286          } 
     1287        } 
     1288      } 
     1289    } 
     1290    else { 
     1291      int len = oldWidth < width ? oldWidth * c : width * c; 
     1292      for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
     1293        int oldIndex = oldWidth * c * y; 
     1294        int index = width * c * (y + hClip) + c * wClip; 
     1295        System.arraycopy(b, oldIndex, padded, index, len); 
     1296      } 
     1297    }   
    12791298    return padded; 
    12801299  } 
     
    12881307  { 
    12891308    int oldHeight = b.length / (oldWidth * c); 
    1290     if (width < oldWidth) width = oldWidth; 
    1291     if (height < oldHeight) height = oldHeight; 
    1292     if (width == oldWidth && height == oldHeight) return b; 
     1309    short[] padded = new short[height * width * c]; 
    12931310 
    12941311    int wClip = (width - oldWidth) / 2; 
    12951312    int hClip = (height - oldHeight) / 2; 
    12961313 
    1297     short[] padded = new short[width * height * c]; 
    1298  
    1299     for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
    1300       int oldIndex = oldWidth * c * oy; 
    1301       int index = width * c * (y + hClip) + c * wClip; 
    1302       System.arraycopy(b, oldIndex, padded, index, oldWidth * c); 
    1303     } 
    1304  
     1314    int h = height < oldHeight ? height : oldHeight; 
     1315    
     1316    if (interleaved) { 
     1317      int len = oldWidth < width ? oldWidth : width; 
     1318      if (h == oldHeight) { 
     1319        for (int y=0; y<h*c; y++) { 
     1320          int oldIndex = oldWidth * y; 
     1321          int index = width * y; 
     1322          System.arraycopy(b, oldIndex, padded, index, len); 
     1323        } 
     1324      } 
     1325      else { 
     1326        for (int ch=0; ch<c; ch++) { 
     1327          for (int y=0; y<h; y++) { 
     1328            int oldIndex = oldWidth * ch * oldHeight + oldWidth * y; 
     1329            int index = width * ch * height + width * y; 
     1330            System.arraycopy(b, oldIndex, padded, index, len); 
     1331          } 
     1332        } 
     1333      } 
     1334    } 
     1335    else { 
     1336      int len = oldWidth < width ? oldWidth * c : width * c; 
     1337      for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
     1338        int oldIndex = oldWidth * c * y; 
     1339        int index = width * c * (y + hClip) + c * wClip; 
     1340        System.arraycopy(b, oldIndex, padded, index, len); 
     1341      } 
     1342    }   
    13051343    return padded; 
    13061344  } 
     
    13141352  { 
    13151353    int oldHeight = b.length / (oldWidth * c); 
    1316     if (width < oldWidth) width = oldWidth; 
    1317     if (height < oldHeight) height = oldHeight; 
    1318     if (width == oldWidth && height == oldHeight) return b; 
     1354    int[] padded = new int[height * width * c]; 
    13191355 
    13201356    int wClip = (width - oldWidth) / 2; 
    13211357    int hClip = (height - oldHeight) / 2; 
    13221358 
    1323     int[] padded = new int[width * height * c]; 
    1324  
    1325     for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
    1326       int oldIndex = oldWidth * c * oy; 
    1327       int index = width * c * (y + hClip) + c * wClip; 
    1328       System.arraycopy(b, oldIndex, padded, index, oldWidth * c); 
    1329     } 
    1330  
     1359    int h = height < oldHeight ? height : oldHeight; 
     1360    
     1361    if (interleaved) { 
     1362      int len = oldWidth < width ? oldWidth : width; 
     1363      if (h == oldHeight) { 
     1364        for (int y=0; y<h*c; y++) { 
     1365          int oldIndex = oldWidth * y; 
     1366          int index = width * y; 
     1367          System.arraycopy(b, oldIndex, padded, index, len); 
     1368        } 
     1369      } 
     1370      else { 
     1371        for (int ch=0; ch<c; ch++) { 
     1372          for (int y=0; y<h; y++) { 
     1373            int oldIndex = oldWidth * ch * oldHeight + oldWidth * y; 
     1374            int index = width * ch * height + width * y; 
     1375            System.arraycopy(b, oldIndex, padded, index, len); 
     1376          } 
     1377        } 
     1378      } 
     1379    } 
     1380    else { 
     1381      int len = oldWidth < width ? oldWidth * c : width * c; 
     1382      for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
     1383        int oldIndex = oldWidth * c * y; 
     1384        int index = width * c * (y + hClip) + c * wClip; 
     1385        System.arraycopy(b, oldIndex, padded, index, len); 
     1386      } 
     1387    }   
    13311388    return padded; 
    13321389  } 
     
    13401397  { 
    13411398    int oldHeight = b.length / (oldWidth * c); 
    1342     if (width < oldWidth) width = oldWidth; 
    1343     if (height < oldHeight) height = oldHeight; 
    1344     if (width == oldWidth && height == oldHeight) return b; 
     1399    float[] padded = new float[height * width * c]; 
    13451400 
    13461401    int wClip = (width - oldWidth) / 2; 
    13471402    int hClip = (height - oldHeight) / 2; 
    13481403 
    1349     float[] padded = new float[width * height * c]; 
    1350  
    1351     for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
    1352       int oldIndex = oldWidth * c * oy; 
    1353       int index = width * c * (y + hClip) + c * wClip; 
    1354       System.arraycopy(b, oldIndex, padded, index, oldWidth * c); 
    1355     } 
    1356  
     1404    int h = height < oldHeight ? height : oldHeight; 
     1405    
     1406    if (interleaved) { 
     1407      int len = oldWidth < width ? oldWidth : width; 
     1408      if (h == oldHeight) { 
     1409        for (int y=0; y<h*c; y++) { 
     1410          int oldIndex = oldWidth * y; 
     1411          int index = width * y; 
     1412          System.arraycopy(b, oldIndex, padded, index, len); 
     1413        } 
     1414      } 
     1415      else { 
     1416        for (int ch=0; ch<c; ch++) { 
     1417          for (int y=0; y<h; y++) { 
     1418            int oldIndex = oldWidth * ch * oldHeight + oldWidth * y; 
     1419            int index = width * ch * height + width * y; 
     1420            System.arraycopy(b, oldIndex, padded, index, len); 
     1421          } 
     1422        } 
     1423      } 
     1424    } 
     1425    else { 
     1426      int len = oldWidth < width ? oldWidth * c : width * c; 
     1427      for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
     1428        int oldIndex = oldWidth * c * y; 
     1429        int index = width * c * (y + hClip) + c * wClip; 
     1430        System.arraycopy(b, oldIndex, padded, index, len); 
     1431      } 
     1432    }   
    13571433    return padded; 
    13581434  } 
     
    13661442  { 
    13671443    int oldHeight = b.length / (oldWidth * c); 
    1368     if (width < oldWidth) width = oldWidth; 
    1369     if (height < oldHeight) height = oldHeight; 
    1370     if (width == oldWidth && height == oldHeight) return b; 
     1444    double[] padded = new double[height * width * c]; 
    13711445 
    13721446    int wClip = (width - oldWidth) / 2; 
    13731447    int hClip = (height - oldHeight) / 2; 
    13741448 
    1375     double[] padded = new double[width * height * c]; 
    1376  
    1377     for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
    1378       int oldIndex = oldWidth * c * oy; 
    1379       int index = width * c * (y + hClip) + c * wClip; 
    1380       System.arraycopy(b, oldIndex, padded, index, oldWidth * c); 
    1381     } 
    1382  
     1449    int h = height < oldHeight ? height : oldHeight; 
     1450    
     1451    if (interleaved) { 
     1452      int len = oldWidth < width ? oldWidth : width; 
     1453      if (h == oldHeight) { 
     1454        for (int y=0; y<h*c; y++) { 
     1455          int oldIndex = oldWidth * y; 
     1456          int index = width * y; 
     1457          System.arraycopy(b, oldIndex, padded, index, len); 
     1458        } 
     1459      } 
     1460      else { 
     1461        for (int ch=0; ch<c; ch++) { 
     1462          for (int y=0; y<h; y++) { 
     1463            int oldIndex = oldWidth * ch * oldHeight + oldWidth * y; 
     1464            int index = width * ch * height + width * y; 
     1465            System.arraycopy(b, oldIndex, padded, index, len); 
     1466          } 
     1467        } 
     1468      } 
     1469    } 
     1470    else { 
     1471      int len = oldWidth < width ? oldWidth * c : width * c; 
     1472      for (int oy=0, y=0; oy<oldHeight; oy++, y++) { 
     1473        int oldIndex = oldWidth * c * y; 
     1474        int index = width * c * (y + hClip) + c * wClip; 
     1475        System.arraycopy(b, oldIndex, padded, index, len); 
     1476      } 
     1477    }   
    13831478    return padded; 
    13841479  } 
  • trunk/loci/formats/ImageViewer.java

    r1806 r1868  
    194194        if (progress.isCanceled()) break; 
    195195        img[i] = myReader.openImage(id, i); 
    196         img[i] = ImageTools.padImage(img[i], myReader.getSizeX(id), 
    197           myReader.getSizeY(id)); 
    198196        if (i == 0) setImages(id, myReader, img); 
    199197        progress.setProgress(i + 2); 
  • trunk/loci/formats/in/BaseTiffReader.java

    r1850 r1868  
    676676      int p = TiffTools.getIFDIntValue(ifds[0], 
    677677        TiffTools.PHOTOMETRIC_INTERPRETATION, true, 0); 
    678       return (!ignoreColorTable && 
     678      return (!isColorTableIgnored() && 
    679679        (p == TiffTools.RGB_PALETTE || p == TiffTools.CFA_ARRAY)) || 
    680680        p == TiffTools.RGB; 
Note: See TracChangeset for help on using the changeset viewer.