Changeset 2012


Ignore:
Timestamp:
01/04/07 12:51:04 (13 years ago)
Author:
chris
Message:

Browser:
1) Multiple threads being created is fixed... now there's only
one continuous low-priority thread... good idea Curtis.

Location:
trunk/loci/plugins/browser
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/plugins/browser/CacheIndicator.java

    r2009 r2012  
    3838  protected double ratio; 
    3939  protected JScrollBar scroll; 
     40  protected boolean doUpdate; 
    4041 
    4142  public CacheIndicator(JScrollBar scroll) { 
     43    doUpdate = true; 
    4244    this.scroll = scroll; 
    4345    setBackground(Color.white); 
     
    4850 
    4951  public void setIndicator(int [] someCache, int [] someLoadList, int length) { 
     52    doUpdate = false; 
    5053    cache = someCache; 
    5154    loadList = someLoadList; 
    5255    cacheLength = length; 
    5356    int setRatio = translate(0); 
     57    doUpdate = true; 
    5458    repaint(); 
    5559  } 
     
    5761  public void paintComponent(Graphics g) { 
    5862    super.paintComponent(g); 
    59     g.setColor(Color.black); 
    60     g.drawRect(0,0,getWidth()-1,COMPONENT_HEIGHT - 1); 
    61  
    62     if(ratio < 1 && ratio != 0) { 
    63       int [] loadCount = new int[getWidth()]; 
    64       int [] cacheCount = new int[getWidth()]; 
    65  
    66       for(int i = 0;i < loadCount.length;i++) { 
    67         loadCount[i] = 0; 
    68         cacheCount[i] = 0; 
     63    if(doUpdate) { 
     64      g.setColor(Color.black); 
     65      g.drawRect(0,0,getWidth()-1,COMPONENT_HEIGHT - 1); 
     66   
     67      if(ratio < 1 && ratio != 0) { 
     68        int [] loadCount = new int[getWidth()]; 
     69        int [] cacheCount = new int[getWidth()]; 
     70   
     71        for(int i = 0;i < loadCount.length;i++) { 
     72          loadCount[i] = 0; 
     73          cacheCount[i] = 0; 
     74        } 
     75   
     76        //find how many entries of the cache are handled per pixel of indicator 
     77        int perPixel; 
     78        double integers = 2; 
     79        double dPerPixel = ratio * integers; 
     80   
     81        if(DEBUG) System.out.println("Ratio: " + ratio); 
     82        while(dPerPixel < 1) { 
     83          integers++; 
     84          dPerPixel = ratio * integers; 
     85        } 
     86   
     87        Double temp = new Double(integers); 
     88        perPixel = temp.intValue(); 
     89   
     90        if(DEBUG) System.out.println("PerPixel: " + perPixel); 
     91   
     92        int colorAmount = 255 / perPixel; 
     93        if(DEBUG) System.out.println("ColorAmount: " + colorAmount); 
     94   
     95        for(int i = 0;i<loadList.length;i++) { 
     96          boolean isLoaded = false; 
     97          if( Arrays.binarySearch(cache, loadList[i]) >= 0) isLoaded = true; 
     98          int index = translate(loadList[i]); 
     99          if(!isLoaded) loadCount[index]++; 
     100        } 
     101        for(int i = 0;i<cache.length;i++) { 
     102          int index = translate(cache[i]); 
     103          cacheCount[index]++; 
     104        } 
     105   
     106        for(int i = 0;i < getWidth();i++) { 
     107          int loadColor,cacheColor; 
     108          loadColor = colorAmount * loadCount[i]; 
     109          cacheColor = colorAmount * cacheCount[i]; 
     110          if(loadColor != 0 || cacheColor != 0) { 
     111            g.setColor(new Color(loadColor,0,cacheColor)); 
     112            g.drawLine(i,1,i,COMPONENT_HEIGHT - 2); 
     113          } 
     114        } 
    69115      } 
    70  
    71       //find how many entries of the cache are handled per pixel of indicator 
    72       int perPixel; 
    73       double integers = 2; 
    74       double dPerPixel = ratio * integers; 
    75  
    76       if(DEBUG) System.out.println("Ratio: " + ratio); 
    77       while(dPerPixel < 1) { 
    78         integers++; 
    79         dPerPixel = ratio * integers; 
    80       } 
    81  
    82       Double temp = new Double(integers); 
    83       perPixel = temp.intValue(); 
    84  
    85       if(DEBUG) System.out.println("PerPixel: " + perPixel); 
    86  
    87       int colorAmount = 255 / perPixel; 
    88       if(DEBUG) System.out.println("ColorAmount: " + colorAmount); 
    89  
    90       for(int i = 0;i<loadList.length;i++) { 
    91         boolean isLoaded = false; 
    92         if( Arrays.binarySearch(cache, loadList[i]) >= 0) isLoaded = true; 
    93         int index = translate(loadList[i]); 
    94         if(!isLoaded) loadCount[index]++; 
    95       } 
    96       for(int i = 0;i<cache.length;i++) { 
    97         int index = translate(cache[i]); 
    98         cacheCount[index]++; 
    99       } 
    100  
    101       for(int i = 0;i < getWidth();i++) { 
    102         int loadColor,cacheColor; 
    103         loadColor = colorAmount * loadCount[i]; 
    104         cacheColor = colorAmount * cacheCount[i]; 
    105         if(loadColor != 0 || cacheColor != 0) { 
    106           g.setColor(new Color(loadColor,0,cacheColor)); 
    107           g.drawLine(i,1,i,COMPONENT_HEIGHT - 2); 
    108         } 
    109       } 
    110     } 
    111     else if (ratio >= 1) { 
    112       int prevLoad = -1; 
    113       int startLoad = -1; 
    114       g.setColor(Color.red); 
    115       for(int i = 0;i<loadList.length;i++) { 
    116         int toLoad = loadList[i]; 
    117  
    118         //correct for bug with length 1 
    119         if(loadList.length == 1) { 
    120           startLoad = toLoad; 
    121           prevLoad = toLoad; 
    122         } 
    123  
    124         if(startLoad == -1) { 
    125           startLoad = toLoad; 
    126           prevLoad = toLoad; 
    127         } 
    128         else if(toLoad == prevLoad + 1 && startLoad != -1) { 
    129           prevLoad = toLoad; 
    130         } 
    131         else if (toLoad != prevLoad +1 && startLoad != -1 && cache.length - 1 != i) { 
    132           prevLoad = prevLoad + 1; 
    133           int x = translate(startLoad); 
    134           int wid = translate(prevLoad) - x; 
    135           g.fillRect(x,1,wid,COMPONENT_HEIGHT - 2); 
    136           startLoad = -1; 
    137         } 
    138          
    139          
    140         if (i == loadList.length - 1) { 
    141           prevLoad = prevLoad + 1; 
    142           int x = translate(startLoad); 
    143           int wid = translate(prevLoad) - x; 
    144           g.fillRect(x,1,wid,COMPONENT_HEIGHT - 2); 
    145           startLoad = -1; 
    146         } 
    147       } 
    148  
    149       prevLoad = -1; 
    150       startLoad = -1; 
    151       g.setColor(Color.blue); 
    152       for(int i = 0;i<cache.length;i++) { 
    153         int toLoad = cache[i]; 
    154  
    155         //correct for bug with length 1 
    156         if(loadList.length == 1) { 
    157           startLoad = toLoad; 
    158           prevLoad = toLoad; 
    159         } 
    160  
    161         if(startLoad == -1) { 
    162           startLoad = toLoad; 
    163           prevLoad = toLoad; 
    164         } 
    165         else if(toLoad == prevLoad + 1 && startLoad != -1) { 
    166           prevLoad = toLoad; 
    167         } 
    168         else if (toLoad != prevLoad +1 && startLoad != -1 && cache.length - 1 != i) { 
    169           prevLoad = prevLoad + 1; 
    170           int x = translate(startLoad); 
    171           int wid = translate(prevLoad) - x; 
    172           g.fillRect(x,1,wid,COMPONENT_HEIGHT - 2); 
    173           startLoad = -1; 
    174         } 
    175          
    176         if (i == cache.length - 1) { 
    177           prevLoad = prevLoad + 1; 
    178           int x = translate(startLoad); 
    179           int wid = translate(prevLoad) - x; 
    180           g.fillRect(x,1,wid,COMPONENT_HEIGHT - 2); 
    181           startLoad = -1; 
     116      else if (ratio >= 1) { 
     117        int prevLoad = -1; 
     118        int startLoad = -1; 
     119        g.setColor(Color.red); 
     120        for(int i = 0;i<loadList.length;i++) { 
     121          if(!doUpdate) break; 
     122          int toLoad = loadList[i]; 
     123   
     124          //correct for bug with length 1 
     125          if(loadList.length == 1) { 
     126            startLoad = toLoad; 
     127            prevLoad = toLoad; 
     128          } 
     129   
     130          if(startLoad == -1) { 
     131            startLoad = toLoad; 
     132            prevLoad = toLoad; 
     133          } 
     134          else if(toLoad == prevLoad + 1 && startLoad != -1) { 
     135            prevLoad = toLoad; 
     136          } 
     137          else if (toLoad != prevLoad +1 && startLoad != -1 && cache.length - 1 != i) { 
     138            prevLoad = prevLoad + 1; 
     139            int x = translate(startLoad); 
     140            int wid = translate(prevLoad) - x; 
     141            g.fillRect(x,1,wid,COMPONENT_HEIGHT - 2); 
     142            startLoad = -1; 
     143          } 
     144           
     145           
     146          if (i == loadList.length - 1) { 
     147            prevLoad = prevLoad + 1; 
     148            int x = translate(startLoad); 
     149            int wid = translate(prevLoad) - x; 
     150            g.fillRect(x,1,wid,COMPONENT_HEIGHT - 2); 
     151            startLoad = -1; 
     152          } 
     153        } 
     154   
     155        prevLoad = -1; 
     156        startLoad = -1; 
     157        g.setColor(Color.blue); 
     158        for(int i = 0;i<cache.length;i++) { 
     159          if(!doUpdate) break; 
     160          int toLoad = cache[i]; 
     161   
     162          //correct for bug with length 1 
     163          if(loadList.length == 1) { 
     164            startLoad = toLoad; 
     165            prevLoad = toLoad; 
     166          } 
     167   
     168          if(startLoad == -1) { 
     169            startLoad = toLoad; 
     170            prevLoad = toLoad; 
     171          } 
     172          else if(toLoad == prevLoad + 1 && startLoad != -1) { 
     173            prevLoad = toLoad; 
     174          } 
     175          else if (toLoad != prevLoad +1 && startLoad != -1 && cache.length - 1 != i) { 
     176            prevLoad = prevLoad + 1; 
     177            int x = translate(startLoad); 
     178            int wid = translate(prevLoad) - x; 
     179            g.fillRect(x,1,wid,COMPONENT_HEIGHT - 2); 
     180            startLoad = -1; 
     181          } 
     182           
     183          if (i == cache.length - 1) { 
     184            prevLoad = prevLoad + 1; 
     185            int x = translate(startLoad); 
     186            int wid = translate(prevLoad) - x; 
     187            g.fillRect(x,1,wid,COMPONENT_HEIGHT - 2); 
     188            startLoad = -1; 
     189          } 
    182190        } 
    183191      } 
  • trunk/loci/plugins/browser/CacheManager.java

    r2009 r2012  
    2929import java.util.Arrays; 
    3030import java.util.Vector; 
     31import java.util.Stack; 
    3132import loci.formats.*; 
    3233import javax.swing.JScrollBar; 
     
    5859 
    5960  /** Flags debug messages on/off.*/ 
    60   public static final boolean DEBUG = true; 
     61  public static final boolean DEBUG = false; 
    6162 
    6263  // -- Fields -- 
     
    138139 
    139140  /** Stop-flag used to stop the caching thread.*/ 
    140   private boolean quit; 
     141  private volatile boolean quit; 
     142   
     143  /** The loading images thread.*/ 
     144  private Thread loader; 
    141145 
    142146  /** 
     
    151155  /** A list of indeces to be loaded by the caching thread.*/ 
    152156  protected int[] loadList; 
     157   
     158  /** The actual queue used by the loader thread to load images.*/ 
     159  protected Stack queue; 
    153160 
    154161  // -- Constructors -- 
     
    207214    oldT = t; 
    208215    oldC = c; 
    209     quit = false; 
    210216    this.fileName = fileName; 
    211217    this.db = db; 
     
    270276    oldZPriority = 1; 
    271277    oldCPriority = 0; 
     278    queue = new Stack(); 
     279    loader = new Thread(this,"Browser-Loader"); 
     280    loader.setPriority(Thread.MIN_PRIORITY); 
     281    loader.start(); 
    272282 
    273283    //Start the caching thread. 
     
    284294  */ 
    285295  public void setAxis(int axis) { 
    286     quit = true; 
    287296    oldAxis = curAxis; 
    288297    curAxis = axis; 
     
    297306  */ 
    298307  public void setMode(int mode) { 
    299     quit = true; 
    300308    oldMode = curMode; 
    301309    curMode = mode; 
     
    310318  */ 
    311319  public void setStrategy(int strategy) { 
    312     quit = true; 
    313320    oldStrategy = this.strategy; 
    314321    this.strategy = strategy; 
     
    345352    int forwardT, int backC, int forwardC) 
    346353  { 
    347     quit = true; 
    348354    oldBackZ = curBackZ; 
    349355    curBackZ = backZ; 
     
    370376    if (top == mid || mid == low || top == low) return; 
    371377 
    372     quit = true; 
    373  
    374378    int storeZ = curZPriority; 
    375379    int storeT = curTPriority; 
     
    522526  */ 
    523527  public ImageProcessor getTempSlice(int index) { 
    524     if (cache[index] != null) return cache[index]; 
    525     return ImagePlusWrapper.getImageProcessor(fileName, read, index); 
     528    if (Arrays.binarySearch(loadList, index) >= 0) { 
     529      if (cache[index] != null) return cache[index]; 
     530      return ImagePlusWrapper.getImageProcessor(fileName, read, index); 
     531    } 
     532    else { 
     533      ImageProcessor result = ImagePlusWrapper.getImageProcessor(fileName, read, index); 
     534      cache[index] = result; 
     535 
     536      updateCache(); 
     537      return result; 
     538    } 
    526539  } 
    527540 
     
    18391852  * we want to cache in the background. 
    18401853  */ 
    1841   private void updateCache() { 
     1854  private synchronized void updateCache() { 
    18421855    if (DEBUG) System.out.println("UPDATING CACHE"); 
    18431856 
    18441857    clearCache(); 
    1845  
    1846     Thread loader = new Thread(this, "Browser-Loader"); 
    1847     loader.start(); 
    1848   } 
    1849  
    1850   /** 
    1851   * Clears the cache and sets the new loadList that the loader 
    1852   * thread will use to start loading slices into the cache. 
    1853   */ 
    1854   private void clearCache() { 
    1855     if (DEBUG) System.out.println("CLEARING CACHE"); 
    1856     quit = true; 
    1857  
    1858     int[] oldIndex = null; 
    1859  
    1860     boolean erase = true; 
    1861     if(!zapCache) { 
    1862       oldIndex = getToCache(true); 
    1863     } 
    1864     else { 
    1865       try { 
    1866         cache = new ImageProcessor[fs.getImageCount(fileName)]; 
    1867       } 
    1868       catch(Exception exc){ 
    1869         LociDataBrowser.exceptionMessage(exc); 
    1870       } 
    1871       erase = false; 
    1872     } 
    1873  
    1874     oldZ = curZ; 
    1875     oldT = curT; 
    1876     oldC = curC; 
    1877  
    1878     oldStrategy = strategy; 
    1879     oldMode = curMode; 
    1880     oldAxis = curAxis; 
    1881  
    1882     oldBackZ = curBackZ; 
    1883     oldBackT = curBackT; 
    1884     oldBackC = curBackC; 
    1885     oldForwardZ = curForwardZ; 
    1886     oldForwardT = curForwardT; 
    1887     oldForwardC = curForwardC; 
    1888  
    1889     oldZPriority = curZPriority; 
    1890     oldTPriority = curZPriority; 
    1891     oldCPriority = curCPriority; 
    1892  
    1893     int[] newIndex = getToCache(false); 
    1894  
    1895     if (DEBUG) { 
    1896           System.out.print("OldIndex = {"); 
    1897           for (int i = 0; i<oldIndex.length; i++) { 
    1898             if ( i != 0) System.out.print(","); 
    1899             System.out.print(oldIndex[i]); 
    1900           } 
    1901           System.out.println("}"); 
    1902  
    1903           System.out.print("NewIndex = {"); 
    1904           for (int i = 0; i<newIndex.length; i++) { 
    1905             if ( i != 0) System.out.print(","); 
    1906             System.out.print(newIndex[i]); 
    1907           } 
    1908           System.out.println("}"); 
    1909           System.out.println("oldBackZ = " + oldBackZ + "; oldForwardZ = " + 
    1910             oldForwardZ + "; oldBackT = " + oldBackT + "; oldForwardT = " + 
    1911             oldForwardT + "; oldBackC = " + oldBackC + "; oldForwardC = " + 
    1912             oldForwardC); 
    1913           System.out.println("curBackZ = " + curBackZ + "; curForwardZ = " + 
    1914             curForwardZ + "; curBackT = " + curBackT + "; curForwardT = " + 
    1915             curForwardT + "; curBackC = " + curBackC + "; curForwardC = " + 
    1916             curForwardC); 
    1917     } 
    1918  
    1919     loadList = new int[newIndex.length]; 
    1920     System.arraycopy(newIndex, 0, loadList, 0, newIndex.length); 
    1921     Arrays.sort(newIndex); 
    1922  
    1923     if(erase) { 
    1924       for (int i = 0; i<oldIndex.length; i++) { 
    1925         if (Arrays.binarySearch(newIndex, oldIndex[i]) < 0) 
    1926           cache[oldIndex[i]] = null; 
    1927       } 
    1928     } 
    1929  
    1930     if (DEBUG) System.out.println("Cache Size after clear: " + getSize()); 
    19311858  } 
    19321859 
     
    20281955    return result; 
    20291956  } 
     1957   
     1958  /** 
     1959  * Clears the cache and sets the new loadList that the loader 
     1960  * thread will use to start loading slices into the cache. 
     1961  */ 
     1962  private void clearCache() { 
     1963    if (DEBUG) System.out.println("CLEARING CACHE"); 
     1964 
     1965    queue = new Stack(); 
     1966    int[] oldIndex = null; 
     1967 
     1968    boolean erase = true; 
     1969    if(!zapCache) { 
     1970      oldIndex = getToCache(true); 
     1971    } 
     1972    else { 
     1973      try { 
     1974        cache = new ImageProcessor[fs.getImageCount(fileName)]; 
     1975      } 
     1976      catch(Exception exc){ 
     1977        LociDataBrowser.exceptionMessage(exc); 
     1978      } 
     1979      erase = false; 
     1980    } 
     1981 
     1982    oldZ = curZ; 
     1983    oldT = curT; 
     1984    oldC = curC; 
     1985 
     1986    oldStrategy = strategy; 
     1987    oldMode = curMode; 
     1988    oldAxis = curAxis; 
     1989 
     1990    oldBackZ = curBackZ; 
     1991    oldBackT = curBackT; 
     1992    oldBackC = curBackC; 
     1993    oldForwardZ = curForwardZ; 
     1994    oldForwardT = curForwardT; 
     1995    oldForwardC = curForwardC; 
     1996 
     1997    oldZPriority = curZPriority; 
     1998    oldTPriority = curZPriority; 
     1999    oldCPriority = curCPriority; 
     2000 
     2001    int[] newIndex = getToCache(false); 
     2002 
     2003    if (DEBUG) { 
     2004      System.out.print("OldIndex = {"); 
     2005      for (int i = 0; i<oldIndex.length; i++) { 
     2006        if ( i != 0) System.out.print(","); 
     2007        System.out.print(oldIndex[i]); 
     2008      } 
     2009      System.out.println("}"); 
     2010 
     2011      System.out.print("NewIndex = {"); 
     2012      for (int i = 0; i<newIndex.length; i++) { 
     2013        if ( i != 0) System.out.print(","); 
     2014        System.out.print(newIndex[i]); 
     2015      } 
     2016      System.out.println("}"); 
     2017      System.out.println("oldBackZ = " + oldBackZ + "; oldForwardZ = " + 
     2018        oldForwardZ + "; oldBackT = " + oldBackT + "; oldForwardT = " + 
     2019        oldForwardT + "; oldBackC = " + oldBackC + "; oldForwardC = " + 
     2020        oldForwardC); 
     2021      System.out.println("curBackZ = " + curBackZ + "; curForwardZ = " + 
     2022        curForwardZ + "; curBackT = " + curBackT + "; curForwardT = " + 
     2023        curForwardT + "; curBackC = " + curBackC + "; curForwardC = " + 
     2024        curForwardC); 
     2025    } 
     2026 
     2027    loadList = new int[newIndex.length]; 
     2028    System.arraycopy(newIndex, 0, loadList, 0, newIndex.length); 
     2029    for(int i = loadList.length -1;i>=0;i--) { 
     2030      Integer temp = new Integer(loadList[i]); 
     2031      queue.push(temp); 
     2032    } 
     2033    Arrays.sort(newIndex); 
     2034 
     2035    if(erase) { 
     2036      for (int i = 0; i<oldIndex.length; i++) { 
     2037        if (Arrays.binarySearch(newIndex, oldIndex[i]) < 0) 
     2038          cache[oldIndex[i]] = null; 
     2039      } 
     2040    } 
     2041 
     2042    if (DEBUG) System.out.println("Cache Size after clear: " + getSize()); 
     2043  } 
    20302044 
    20312045  // -- Runnable API methods -- 
     
    20352049    quit = false; 
    20362050 
    2037     for (int i = 0; i<loadList.length; i++) { 
    2038       if (quit) break; 
    2039       if (cache[loadList[i]] == null) { 
    2040         if (DEBUG) System.out.println("CACHING... index: " + loadList[i]); 
    2041  
     2051    while(!quit) { 
     2052      if(!queue.empty()) { 
     2053        int index = ((Integer)queue.pop()).intValue(); 
     2054        System.out.println("Loading index " + index); 
    20422055        ImageProcessor imp = ImagePlusWrapper.getImageProcessor( 
    2043           fileName, read, loadList[i]); 
    2044         cache[loadList[i]] = imp; 
    2045       } 
    2046        
    2047       if (quit) break; 
    2048       if(db.cw != null) { 
    2049         int aC = 1; 
    2050         zSel = db.cw.zSliceSel; 
    2051         tSel = db.cw.tSliceSel; 
    2052         if (sizeC != 0) aC = (db.cw.getC()); 
    2053         if (quit) break; 
    2054         setIndicators(zSel.getValue(), tSel.getValue(), aC); 
    2055       } 
    2056     } 
    2057   } 
    2058  
     2056          fileName, read, index); 
     2057        cache[index] = imp; 
     2058         
     2059        if(db.cw != null) { 
     2060          int aC = 1; 
     2061          zSel = db.cw.zSliceSel; 
     2062          tSel = db.cw.tSliceSel; 
     2063          if (sizeC != 0) aC = (db.cw.getC()); 
     2064          if (quit) break; 
     2065          setIndicators(zSel.getValue(), tSel.getValue(), aC); 
     2066        } 
     2067      } 
     2068      if(db == null) quit = true; 
     2069    } 
     2070  } 
     2071   
    20592072} 
Note: See TracChangeset for help on using the changeset viewer.