Changeset 2973


Ignore:
Timestamp:
07/13/07 14:37:50 (13 years ago)
Author:
curtis
Message:

Woo, cache logic appears to be working.

Location:
trunk/loci/formats/cache
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/cache/Cache.java

    r2969 r2973  
    1010 
    1111public class Cache { 
     12 
     13  // -- Static fields -- 
     14 
     15  /** Whether to generate debugging output. */ 
     16  private static boolean debug = false; 
    1217 
    1318  // -- Fields -- 
     
    123128    for (int i=0; i<indices.length; i++) { 
    124129      int ndx = FormatTools.positionToRaster(len, indices[i]); 
    125       if (ndx >= 0 && cache[ndx] == null) { 
     130      if (cache[ndx] == null) { 
     131        if (debug) printArray("Loading position", indices[i]); 
    126132        cache[ndx] = source.getObject(len, indices[i]); 
    127133      } 
     134      else if (debug) printArray("Already in cache", indices[i]); 
    128135    } 
    129136  } 
     
    149156      System.exit(1); 
    150157    } 
     158    debug = true; 
    151159    ImageReader reader = new ImageReader(); 
    152160    String id = args[0]; 
  • trunk/loci/formats/cache/CacheStrategy.java

    r2968 r2973  
    8585        if (value == 0) return 0; 
    8686        int vb = lengths[axis] - value; 
    87         return value <= vb ? 2 * value - 1 : 2 * vb; 
     87        return value <= vb ? value : vb; 
    8888      case FORWARD_ORDER: 
    8989        return value; 
     
    146146      } 
    147147 
    148       // build load list from current pos, positions list, load order and range 
    149       int count = 0; 
     148      // count up number of load list entries 
     149      int c = 0; 
    150150      for (int i=0; i<positions.length; i++) { 
    151151        int[] ipos = positions[i]; 
    152152 
    153         // compute total distance from current pos 
    154         int dist = 0; 
     153        // verify position is close enough to current position 
     154        boolean ok = true; 
    155155        for (int j=0; j<ipos.length; j++) { 
    156           if (distance(j, ipos[j]) > range[j]) continue; // out of range 
    157         } 
    158  
    159         // position is in range 
    160         count++; 
    161       } 
    162  
    163       loadList = new int[count][lengths.length]; 
    164       int c = 0; 
    165  
    166       // populate load list 
     156          if (distance(j, ipos[j]) > range[j]) { 
     157            ok = false; 
     158            break; 
     159          } 
     160        } 
     161        if (ok) c++; // in range 
     162      } 
     163 
     164      loadList = new int[c][lengths.length]; 
     165      c = 0; 
     166 
     167      // build load list 
    167168      for (int i=0; i<positions.length; i++) { 
    168169        int[] ipos = positions[i]; 
    169170 
    170         // compute total distance from current pos 
    171         int dist = 0; 
    172         for (int j=0; j<ipos.length; j++) { 
    173           if (distance(j, ipos[j]) > range[j]) continue; // out of range 
     171        // verify position is close enough to current position 
     172        boolean ok = true; 
     173        for (int j=0; j<ipos.length && c<loadList.length; j++) { 
     174          if (distance(j, ipos[j]) > range[j]) { 
     175            ok = false; 
     176            break; 
     177          } 
    174178          int value = (pos[j] + ipos[j]) % lengths[j]; // normalize axis value 
    175179          loadList[c][j] = value; 
    176180        } 
    177         c++; 
     181        if (ok) c++; // in range; lock in load list entry 
    178182      } 
    179183    } 
  • trunk/loci/formats/cache/CrosshairStrategy.java

    r2968 r2973  
    1818 * <p> 
    1919 * To illustrate the crosshair strategy, here is a diagram showing a case 
    20  * in 2D with 56 dimensional positions (7Z x 8T). For both Z and T, order is 
     20 * in 2D with 35 dimensional positions (5Z x 7T). For both Z and T, order is 
    2121 * centered, range is 2, and priority is normal. 
    2222 * The numbers indicate the order planes will be cached, with "0" 
    23  * corresponding to the current dimensional position. 
     23 * corresponding to the current dimensional position (Z2-3T). 
    2424 * <pre> 
    25  *      T  0  1  2  3  4  5  6  7 
    26  *    Z /------------------------ 
    27  *    0 | 
    28  *    1 |           8 
    29  *    2 |           4 
    30  *    3 |     7  3  0  1  5 
    31  *    4 |           2 
    32  *    5 |           6 
    33  *    6 | 
     25 *      T  0  1  2  3  4  5  6 
     26 *    Z /--------------------- 
     27 *    0 |           6 
     28 *    1 |           2 
     29 *    2 |     8  4  0  3  7 
     30 *    3 |           1 
     31 *    4 |           5 
    3432 * </pre> 
    3533 */ 
  • trunk/loci/formats/cache/RectangleStrategy.java

    r2968 r2973  
    1919 * <p> 
    2020 * To illustrate the rectangle strategy, here is a diagram showing a case 
    21  * in 2D with 56 dimensional positions (7Z x 8T). For both Z and T, order is 
    22  * centered, range is 5, and priority is normal. 
     21 * in 2D with 35 dimensional positions (5Z x 7T). For both Z and T, order is 
     22 * centered, range is 2, and priority is normal. 
    2323 * The numbers indicate the order planes will be cached, with "0" 
    24  * corresponding to the current dimensional position. 
     24 * corresponding to the current dimensional position (Z2-T3). 
    2525 * <pre> 
    26  *      T  0  1  2  3  4  5  6  7 
    27  *    Z /------------------------ 
    28  *    0 | 
    29  *    1 |    24 20  7 16 23 
    30  *    2 |    19 14  4  9 17 
    31  *    3 |    10  3  0  1  6 
    32  *    4 |    15  8  2  5 12 
    33  *    5 |    22 18 11 13 21 
    34  *    6 | 
     26 *      T  0  1  2  3  4  5  6  
     27 *    Z /--------------------- 
     28 *    0 |    24 20  6 14 22    
     29 *    1 |    18 12  2 10 16   
     30 *    2 |     8  4  0  3  7    
     31 *    3 |    17 11  1  9 15    
     32 *    4 |    23 19  5 13 21    
    3533 * </pre> 
    3634 */ 
Note: See TracChangeset for help on using the changeset viewer.