package com.github.celldynamics.quimp.plugin.qanalysis;
   
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import com.github.celldynamics.quimp.QColor;
   import com.github.celldynamics.quimp.utils.QuimPArrayUtils;
   
   /**
   * Hold fluorescence map for given channel together with indexed colors.
   * 
   * @author rtyson
   */
  
  public class FluoMap {
  
    /**
     * The Constant LOGGER.
     */
    static final Logger LOGGER = LoggerFactory.getLogger(FluoMap.class.getName());
    /**
     * Number of frames. Part of QCONF.
     */
    private int T;
    /**
     * Horizontal resolution (points of outline). Part of QCONF.
     */
    private int res;
    /**
     * Fluorescence channel kept in this object. Part of QCONF.
     */
    private int channel;
    /**
     * Fluorescence map [time points][outline points]. Part of QCONF.
     */
    private double[][] map;
    /**
     * Colors for intensities stored in map.
     * 
     * <p>1D array is mapped to map[tt][p] as pN = (tt * res) + p;
     * Part of QCONF.
     */
    byte[] fluColor;
    /**
     * If no data switch false. Part of QCONF.
     */
    boolean enabled;
  
    /**
     * Copy constructor.
     * 
     * @param src source object
     */
    public FluoMapynamics/quimp/plugin/qanalysis/FluoMap.html#FluoMap">FluoMap(final FluoMap src) {
      this.T = src.T;
      this.res = src.res;
      this.channel = src.channel;
      this.map = QuimPArrayUtils.copy2darray(src.map, null);
      this.fluColor = new byte[src.fluColor.length];
      System.arraycopy(src.fluColor, 0, this.fluColor, 0, src.fluColor.length);
      this.enabled = src.enabled;
    }
  
    /**
     * Constructor.
     * 
     * @param t number of time points
     * @param r resolution
     * @param i channel
     */
    public FluoMap(int t, int r, int i) {
      T = t;
      res = r;
      channel = i;
      enabled = true;
      map = new double[T][res];
      fluColor = new byte[T * res];
    }
  
    /**
     * Enables this map.
     * 
     * @param b status
     */
    public void setEnabled(boolean b) {
      enabled = b;
    }
  
    /**
     * Check if enabled.
     * 
     * @return true if enabled
     */
    public boolean isEnabled() {
      return enabled;
    }
  
    /**
     * Put value to fluoromap calculating correct color.
    * 
    * @param t time
    * @param p membrane pixel
    * @param pn linear index for <tt>fluColor</tt>
    * @param intensity fluoroscence intensity to store at <tt>map</tt>
    * @param max value to scale to colors
    * @see #recalculateColorScale(double)
    */
   public void fill(int t, int p, int pn, double intensity, double max) {
     map[t][p] = intensity;
     fluColor[pn] = (byte) QColor.bwScale(intensity, 256, max, 0); // don't bother scaling
   }
 
   /**
    * Recalculate colors for <tt>map</tt> array.
    * 
    * @param max Value to scale to colors. Usually it is maximum of map.
    * @see #fill(int, int, int, double, double)
    */
   public void recalculateColorScale(double max) {
     LOGGER.debug("Recalculate fluColor, max=" + max + " enabled state:" + isEnabled());
     if (!isEnabled()) {
       return; // do not if not enabled (e.g. not initialized)
     }
     int pn;
     double intensity;
     for (int r = 0; r < res; r++) {
       for (int t = 0; t < T; t++) {
         pn = t * res + r;
         intensity = map[t][r];
         fluColor[pn] = (byte) QColor.bwScale(intensity, 256, max, 0);
       }
     }
 
   }
 
   /**
    * getColours.
    * 
    * @return fluColor
    */
   public byte[] getColours() {
     return fluColor;
   }
 
   /**
    * getMap.
    * 
    * @return map
    */
   public double[][] getMap() {
     return map;
   }
 
   /**
    * getChannel.
    * 
    * @return the channel
    */
   public int getChannel() {
     return channel;
   }
 
   /**
    * Set new fluorescence map calculating also adequate colorscale. Set this map enabled.
    * 
    * @param map the map to set
    */
   public void setMap(double[][] map) {
     this.map = map;
     recalculateColorScale(QuimPArrayUtils.array2dMax(map));
     setEnabled(true);
     T = map.length;
     res = map[0].length;
   }
 }