/*
Copyright @ 2003, The Institute for Genomic Research (TIGR).
All rights reserved.
*/

/*****************************************************************************
 * Description:  A class that reads a set of GenePix (gpr) files and write to
 *               MEV files.
 * Company:      TIGR
 * @author       Jianwei (Jerry) Li
 * @version 1.5
 * @Date:  Created: 02/25/2003 and modified:  06/04/2004
 * Modified history:
 * 06/04/04: provides the option to write only one ann file for a set of mev
 *           files that are produced with the same array design.
 *****************************************************************************/
package org.tigr.microarray.converter;

import java.util.*;
import java.awt.*;
import java.io.*;
import javax.swing.*;

import org.tigr.microarray.MevAttributes;
import org.tigr.util.FileReading;
import org.tigr.util.StringSplitter;
import org.tigr.util.io.MyIni;
import org.tigr.util.io.IOUtil;
import org.tigr.util.MyTimer;

public class GenepixMev extends MevConverter implements MevAttributes{
  private String bgChA, bgChB, bgChAn, bgChBn;
  private String chA, chAn, chB, chBn;
  private String chAs, chAsn, chBs, chBsn;
  private String title;  // the massege showed on the bars of all windows.
  private Vector mevFileNames;
  private int fPixAddr, gAnnType;

  private final int FIRST_NUM = 1;

  private final String FLAG = "\"Flags\"";
  private final String BLOCK = "\"Block\"";
  private final String COLUMN = "\"Column\"";
  private final String RW = "\"Row\"";
  private final String F_PIX = "\"F Pixels\"";
  private final String FLAG_N = "Flags";
  private final String BLOCK_N = "Block";
  private final String COLUMN_N = "Column";
  private final String ROW_N = "Row";
  private final String F_PIX_N = "F Pixels";
  private final String WAVE_KEY_1 = "ImageName";
  private final String WAVE_KEY_2 = "Wavelengths";
  final String ID = "ID";
  final String ID_N = "\"ID\"";
  final String NAME = "Name";
  final String NAME_N = "\"Name\"";

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> gfName --- the name of GenePix file to be converted.
   *<br> mfName --- the name of .mev file that is an output.
   *****************************************************************************/
  public GenepixMev(String gfName, String mfName) {
    super();
    inFileNames = new Vector(1);
    mevFileNames = new Vector(1);
    inFileNames.add(gfName);
    mevFileNames.add(mfName);
    title = new String("Genepix vs Mev");
  }

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> gfNames --- the names of GenePix files to be converted.
   *<br> mfNames --- the names of .mev files that is an output.
   * <br> barTitle --- the string on the bar.
   * <br> annNum --- the ann file type, one for one / many for one.
   *****************************************************************************/
  public GenepixMev(Vector gfNames, Vector mfNames, String barTitle, int annNum) {
    super();
    inFileNames = gfNames;
    mevFileNames = mfNames;
    title = barTitle;
    gAnnType = annNum;
  }

  /***************************************************************************
   * <b>Description: </b>
   *   overrides an abstract method to implement the main function of class.
   **************************************************************************/
  public void run () {
    boolean going, noError;
    String aLine = new String("");
    String densA = new String("");
    String densB = new String("");
    String flagA = new String("");
    String flagB = new String("");
    String bgA = new String("");  // background info for channel A
    String bgB = new String("");  // background info for channel B
    String medA = new String("");
    String medB = new String("");
    String mevFileName;
    String annoFileNamePath, oneAnnFileName;
    String gprFileName;
    String colValues[];
    String extraInfo = new String("");
    String colNames[];
    String mevFileHeader[];
    String annoFile[] = null;
    String waves[] = new String[2]; // first for channel A and second for B.
    StringBuffer mevLine = new StringBuffer(200);
    int hLines;
    int max = 0;
    int maxRow = 0;
    int maxCol = 0;
    int ident;
    int maxMetaCol, block, row, col, metaRow, metaCol, slideRow, slideCol, spAreaA, spAreaB;
    int i, j, k, flagInt, flagIndex, blockIndex, colIndex, rowIndex, idIndex, nameIndex;
    int f635m, b635m, f635s, f532m, f532s, b532m;
    int numOfFiles;
    int fSize;
    BufferedWriter mevWriter = null;
    BufferedWriter annoWriter = null;
    FileOutputStream mevFileOut = null;
    FileReading fileReader;
    Vector genepixFile = null;

    taskEnd = determineTaskEnd();
    if(taskEnd == 1){
      return;
    }
    taskEnd <<= 1;

    counter = 0;
    numOfFiles = inFileNames.size();

    for(i=0; i<numOfFiles; i++){
      noError = true;
      inFileNamePath = (String)inFileNames.elementAt(i);
      mevFileName = (String)mevFileNames.elementAt(i);
      try {
        fileReader = new FileReading(inFileNamePath);
        if(fileReader.done){
          genepixFile = fileReader.getFileContentInLines();
        } else {
          taskEnd = 1;
          counter = 1;
          setErrorMessage(fileReader.getProcessMessage());
          return;
        }
      } catch (IOException e){
        taskEnd = 1;
        counter = 1;
        setErrorMessage(e.getMessage());
        return;
      }

      fSize = genepixFile.size();
        // determing the number of lines for header info
      hLines = 0;
      going = true;
      while(going){
        aLine = (String)genepixFile.elementAt(hLines);
        if(aLine.charAt(0) == '"' || isChar(aLine.charAt(0))){
          // scanner could use different wavelength for the two chennels
          if(isWaveLengthDefination(aLine)){
            waves = getWaveLengths(aLine);
          }
          going = true;
          hLines++;
        } else {
          if(hLines == FIRST_NUM){
            going = true;
            hLines++;
          } else{
            going = false;
          }
        }
      }

      defineKeys(waves);
      aLine = (String)genepixFile.elementAt(hLines-1);
      colNames = separateLine(aLine);

      blockIndex = findRightCol(colNames, BLOCK, BLOCK_N);
      colIndex = findRightCol(colNames, COLUMN, COLUMN_N);
      rowIndex = findRightCol(colNames, RW, ROW_N);

      aLine = (String)genepixFile.elementAt(fSize-1);
      colValues = separateLine(aLine);

      if(colValues.length > 2){
        max = Integer.parseInt(colValues[blockIndex]);
        maxCol = Integer.parseInt(colValues[colIndex]);
        maxRow = Integer.parseInt(colValues[rowIndex]);
      } else {
        JOptionPane.showMessageDialog(null,
          "You might add extra space at the end of file.\n(" + inFileNamePath +
          "). \nPlease remove it and try again. Converting will continue " +
          "\nfor remaining files", title + " -- Gpr-Mev",
          JOptionPane.ERROR_MESSAGE);
        noError = false;
        counter += numOfFiles;
      }

      if(noError){
        if(max <= 12){
          maxMetaCol = 2;
        } else {
          maxMetaCol = 4;
        }

          // check if the original file has been modified.
        noError = true;
        if((max * maxCol * maxRow) + hLines != genepixFile.size()){
          JOptionPane.showMessageDialog(null,
            "You might have dropped some of your spots in the file \n(" +
            inFileNamePath + ".\nThe converter requires an original GenePix file." +
            "\nConverting will continue for the remaining files",
            title + " -- Gpr-Mev", JOptionPane.ERROR_MESSAGE);
          noError = false;
          counter += numOfFiles;
        }

        if(noError){
          flagIndex = findRightCol(colNames, FLAG, FLAG_N);
          fPixAddr = findRightCol(colNames, F_PIX, F_PIX_N);

          f635m = findRightCol(colNames, chA, chAn);
          f635s = findRightCol(colNames, chAs, chAsn);
          b635m = findRightCol(colNames, bgChA, bgChAn);

          f532m = findRightCol(colNames, chB, chBn);
          f532s = findRightCol(colNames, chBs, chBsn);
          b532m = findRightCol(colNames, bgChB, bgChBn);

          idIndex = findRightCol(colNames, ID, ID_N);
          nameIndex = findRightCol(colNames, NAME, NAME_N);

          try{
            annoFileNamePath = IOUtil.dropExtension(mevFileName);
            annoFileNamePath += ".ann";

            mevFileOut = new FileOutputStream(mevFileName);
            mevWriter = new BufferedWriter(new OutputStreamWriter(mevFileOut));

            sortKeys = new int[NUM_SORT][fSize - hLines];
            outFile = new String[fSize - hLines];
            gprFileName = IOUtil.extractFileNameFromPath(inFileNamePath);

            // generate MEV file header
            mevFileHeader = generateHeader(gprFileName, fSize-hLines, true);

            for(j=0; j<mevFileHeader.length; j++){
              mevWriter.write(mevFileHeader[j]);
              mevWriter.newLine();
              mevWriter.flush();
            }

            if(gAnnType == ExpressConverter.ONE_FILE){
              annoFile = new String[fSize - hLines];
              annoWriter = createAnnoWriter(annoFileNamePath, gprFileName, fSize-hLines);
            } else if (i < 1){
              annoFile = new String[fSize - hLines];
              annoWriter = createAnnoWriter(annoFileNamePath, gprFileName, fSize-hLines);
            }

            counter += hLines;
            ident = 1;
            for(j = hLines, k=0; j<fSize; j++, k++){
              aLine = (String)genepixFile.elementAt(j);
              colValues = separateLine(aLine);

              block = Integer.parseInt(colValues[blockIndex]);
              col = Integer.parseInt(colValues[colIndex]);
              row = Integer.parseInt(colValues[rowIndex]);

                // channel A is always for Cy3 and B for Cy3 in .tav file
              spAreaA = calculateSpotDimeter(colValues, f532s);
              spAreaB = calculateSpotDimeter(colValues, f635s);

              flagA = setFlag(colValues, f532s, flagIndex);
              flagB = setFlag(colValues, f635s, flagIndex);

              metaRow = ((block -1) / maxMetaCol) + 1;
              metaCol = ((block -1) % maxMetaCol) + 1;
              slideRow = (metaRow - 1) * maxRow + row;
              slideCol = (metaCol -1 ) * maxCol + col;

              bgA = calculateBackground(colValues, b532m);
              bgB = calculateBackground(colValues, b635m);

              mevLine.append(ident).append(TAB);

              if(gBkgCorrect){
                densA = calculateIntegrateDensity(colValues, f532m, f532s, b532m, true);
                densB = calculateIntegrateDensity(colValues, f635m, f635s, b635m, true);
                medA = calculateMedianIntensity(colValues, f532m, b532m, true);
                medB = calculateMedianIntensity(colValues, f635m, b635m, true);
              } else {
                densA = calculateIntegrateDensity(colValues, f532m, f532s, b532m, false);
                densB = calculateIntegrateDensity(colValues, f635m, f635s, b635m, false);
                medA = calculateMedianIntensity(colValues, f532m, b532m, false);
                medB = calculateMedianIntensity(colValues, f635m, b635m, false);
              }

              if(gUseMedian){
                mevLine.append(medA).append(TAB).append(medB);
                aLine = densA + TAB + densB;
              } else {
                mevLine.append(densA).append(TAB).append(densB);
                aLine = medA + TAB + medB;
              }

              mevLine.append(TAB).append(slideRow).append(TAB).append(slideCol);
              mevLine.append(TAB).append(metaRow).append(TAB).append(metaCol);
              mevLine.append(TAB).append(row).append(TAB).append(col).append(TAB);
              mevLine.append(bgA).append(TAB).append(bgB).append(TAB).append(flagA);
              mevLine.append(TAB).append(flagB).append(TAB).append(spAreaA).append(TAB);
              mevLine.append(spAreaB).append(TAB).append(aLine);

              outFile[k] = new String(mevLine.toString());
              mevLine.delete(0, mevLine.length());

              if(gAnnType == ExpressConverter.ONE_FILE){
                extraInfo = ident + TAB + slideRow + TAB + slideCol + TAB +
                  colValues[nameIndex] + TAB + colValues[idIndex];;
                annoFile[k] = new String(extraInfo);
              } else if (i < 1){
                extraInfo = ident + TAB + slideRow + TAB + slideCol + TAB +
                  colValues[nameIndex] + TAB + colValues[idIndex];
                annoFile[k] = new String(extraInfo);
              }

              sortKeys[0][k] = k;
              sortKeys[1][k] = slideRow;
              sortKeys[2][k] = slideCol;

              ident++;
              counter++;
            } // end of the for loop for a single file.

            if(wantSort){
              sorted = sortRowCol(maxMetaCol, maxCol);
              // write to file
              for(j = 0; j<outFile.length; j++){
                mevWriter.write(outFile[sorted[j]]);
                mevWriter.newLine();
                mevWriter.flush();

                if(gAnnType == ExpressConverter.ONE_FILE){
                  annoWriter.write(annoFile[sorted[j]]);
                  annoWriter.newLine();
                  annoWriter.flush();
                } else if (i < 1){
                  annoWriter.write(annoFile[sorted[j]]);
                  annoWriter.newLine();
                  annoWriter.flush();
                }
                counter++;
              }
            } else {
              for(j = 0; j<outFile.length; j++){
                mevWriter.write(outFile[j]);
                mevWriter.newLine();
                mevWriter.flush();

                if(gAnnType == ExpressConverter.ONE_FILE){
                  annoWriter.write(annoFile[j]);
                  annoWriter.newLine();
                  annoWriter.flush();
                } else if (i < 1){
                  annoWriter.write(annoFile[j]);
                  annoWriter.newLine();
                  annoWriter.flush();
                }
                counter++;
              }
            }
            mevFileOut.close();
            if(gAnnType == ExpressConverter.ONE_FILE){
              annoWriter.close();
            } else if (i<1){
              annoWriter.close();
            }
          } catch (IOException ie){
            fetalError = true;
            ready = false;
            System.out.println("Error in writing file: " + ie.getMessage());
            msg += "**********\n";
            msg += "Error in writing file: " + ie.getMessage() + "\n";
            return;
          } catch (Exception e){
            fetalError = true;
            ready = false;
            msg += "**********\n";
            msg += "Error: " + e.getMessage() + ". Please report the developer.\n";
            return;
          }
        }
      }
    } // end of for loop for number of files.
    ready = true;
    counter = taskEnd;
  }

  /*****************************************************************************
   * <b>Description: </b>
   *   calculates the spot area in terms of pixel number.
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row.
   * <br> sat -- address for saturated pixels column.
   * <p><b>Return: </b> the spot area.
   ***************************************************************************/
  private int calculateSpotDimeter(String[] tuple, int sat){
    float fSat, fPix;
    int temp;

    fPix = Float.parseFloat(tuple[fPixAddr]);
    fSat = Float.parseFloat(tuple[sat]);
    fSat = fSat / 100;
    temp = (int) (fPix * (1 - fSat));
    return temp;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   calculate background for a channel with bg = median * area
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> backg -- address for background medien column
   * <p><b>Return: </b> the background information
   ***************************************************************************/
  private String calculateBackground(String[] tuple, int backg){
    float fPix, bMedian;
    int temp;
    //float temp;
    String bg = new String("");

    try{
      fPix = Float.parseFloat(tuple[fPixAddr]);
      bMedian = Float.parseFloat(tuple[backg]);
      temp = (int)(bMedian * fPix);
      //temp = (bMedian * fPix);
      bg += temp;
    }  catch (NumberFormatException nfex) {
      minorError = true;
      bg = "null";
      msg += "**********\n";
      msg += "There is an unacceptable value for either F Pixcel or B Median;\n";
      msg += "and the background was set to null.\n";
    }
    return bg;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   calculate integrate intensity for a channel
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> med -- address for either channel A or B median column
   * <br> sat -- address for saturated pixels.
   * <br> backg -- address for background medien column
   * <br> bgSub -- indicate if an intensity should subtract backgroud.
   * <p><b>Return: </b> the density
   ***************************************************************************/
  private String calculateIntegrateDensity(String[] tuple, int med, int sat, int backg,
                                           boolean bgSub){
    float fMedian, bMedian, fPix, fSat;
    int temp;
    String den = new String("");

    try{
      fMedian = Float.parseFloat(tuple[med]);
      bMedian = Float.parseFloat(tuple[backg]);

      fPix = Float.parseFloat(tuple[fPixAddr]);
      fSat = Float.parseFloat(tuple[sat]);
      fSat = fSat / 100;

      if(bgSub){
        temp = (int)(fPix * (fMedian - bMedian) * ( 1 - fSat));
      } else {
        temp = (int)(fPix * fMedian * ( 1 - fSat));
      }

      den += temp;
    }  catch (NumberFormatException nfex) {
      minorError = true;
      den = "null";
      msg += "**********\n";
      msg += "There is an unacceptable value to calculate intensity; and the intensity was set to null.\n";
    }
    return den;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   calculate median intensity for a channel
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> med -- address for either channel A or B median column
   * <br> backg -- address for background medien column
   * <br> bgSub -- indicate if an intensity should subtract backgroud.
   * <p><b>Return: </b> the density
   ***************************************************************************/
  private String calculateMedianIntensity(String[] tuple, int med, int backg,
                                           boolean bgSub){
    float fMedian, bMedian;
    float temp;
    String den = new String("");

    try{
      fMedian = Float.parseFloat(tuple[med]);
      bMedian = Float.parseFloat(tuple[backg]);

      if(bgSub){
        temp = fMedian - bMedian;
      } else {
        temp = fMedian;
      }

      den += (int)temp;
    }  catch (NumberFormatException nfex) {
      minorError = true;
      den = "null";
      msg += "**********\n";
      msg += "There is an unacceptable value to calculate intensity; and the intensity was set to null.\n";
    }
    return den;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   creates a header for both mev and dat(annotation) file.
   * <p><b>Parameter: </b>
   * <br> fName -- the mev file name that should be written to the file.
   * <br> numRow -- the number of spots (genes/row).
   * <br> mev -- indicate if the header is for ann or mev.
   * <p><b>Return: </b> the header as an array.
   **************************************************************************/
  private String[] generateHeader(String fName, int numRow, boolean mev){
    String[] tempHeader;
    String bkgVal;

    if(mev){
      tempHeader = new String[8];
    } else {
      tempHeader = new String[7];
    }

    if(gBkgCorrect){
      bkgVal = ON;
    } else {
      bkgVal = OFF;
    }

    tempHeader[0] = new String(PAN + SPACE + VERSION + COLON + " V1.0");
    tempHeader[1] = new String(PAN + SPACE + FORMAT_VERSION + COLON + ExpressConverter.MEV_VER);
    tempHeader[2] = new String(PAN + SPACE + DATE + COLON + SPACE + MyTimer.getCurrentDateAndTime('.'));
    tempHeader[3] = new String(PAN + SPACE + CREATED_BY + COLON + SPACE + title);
    tempHeader[4] = new String(PAN + SPACE + ROW_COUNT + COLON + numRow);
    tempHeader[5] = new String(PAN + " converted from GenePix file: " + fName);

    if(mev){
      tempHeader[6] = new String(PAN + SPACE + BKG_CORRECT + COLON + bkgVal);
      if(gUseMedian){
        tempHeader[7] = UID + TAB + MEDA + TAB + MEDB + TAB + R + TAB + C + TAB +
          MR + TAB + MC + TAB + SR + TAB + SC + TAB + BKGA + TAB + BKGB + TAB +
          FLAGA + TAB + FLAGB + TAB + SAA + TAB + SAB + TAB + IA + TAB + IB;
      } else {
        tempHeader[7] = UID + TAB + IA + TAB +	IB + TAB + R + TAB + C + TAB +
          MR + TAB + MC + TAB + SR + TAB + SC + TAB + BKGA + TAB + BKGB + TAB +
          FLAGA + TAB + FLAGB + TAB + SAA + TAB + SAB + TAB + MEDA + TAB + MEDB;
      }
    } else {
      tempHeader[6] = UID + TAB + R + TAB + C + TAB + NAME + TAB + ID;
    }

    return tempHeader;
  }

  /****************************************************************************
   * <b>Description: </b>
   *    find the wave lengths from the header information
   * <p><b>Parameters: </b>
   * <br> str -- a line of the file that contains wave lengths.
   * <P><b>Return: </b> the wave lengths as an array.
   ****************************************************************************/
  private String[] getWaveLengths(String str){
    int num;
    String wv;
    String tempWave[] = new String[2];
    String wavStr = new String(str.substring(str.indexOf('=')+1, str.lastIndexOf('\"')));
    StringTokenizer token = new StringTokenizer(wavStr);

    num = 0;
    while(token.hasMoreTokens()){
      wv = token.nextToken();
      if(isNumber(wv)){
        tempWave[num] = new String(wv);
        num++;
      }
    }
    return tempWave;
  }

  /**************************************************************************
   * <b>Description: </b>
   *    instantiates a writer object for ann file writing.
   * <p><b>Parameters: </b>
   * <br> fName --- ann file name to be written.
   * <br> inName --- the input file name.
   * <br> numSpots --- the number of rows in the input file.
   * <p><b>Return: </b>  the writer
   ****************************************************************************/
  private BufferedWriter createAnnoWriter(String fName, String inName, int numSpots){
    BufferedWriter out;
    FileOutputStream fOut;
    String annoFileHeader[];

    try {
      fOut = new FileOutputStream(fName);
      out = new BufferedWriter(new OutputStreamWriter(fOut));

      annoFileHeader = generateHeader(inName, numSpots, false);

      for(int i=0; i<annoFileHeader.length; i++){
        out.write(annoFileHeader[i]);
        out.newLine();
        out.flush();
      }
    } catch (IOException ie){
      fetalError = true;
      ready = false;
      System.out.println("Error in creating ann file: " + ie.getMessage());
      msg += "**********\n";
      msg += "Error in creating ann file: " + ie.getMessage() + "\n";
      return null;
    }

    return out;
  }

  /****************************************************************************
   * <b>Description: </b>
   *    assignes values to the keys for searching right columns.
   * <p><b>Parameter: </b>
   * <br> wvs --- the wave lenghts.
   ***************************************************************************/
  private void defineKeys(String[] wvs) {
    chA = new String("\"F" + wvs[0] + " Median\"");
    chB = new String("\"F" + wvs[1] + " Median\"");
    chAs = new String("\"F" + wvs[0] + " % Sat.\"");
    chBs = new String("\"F" + wvs[1] + " % Sat.\"");
    bgChA = new String("\"B" + wvs[0] + " Median\"");
    bgChB = new String("\"B" + wvs[1] + " Median\"");

    chAn = new String("F" + wvs[0] + " Median");
    chBn = new String("F" + wvs[1] + " Median");
    chAsn = new String("F" + wvs[0] + " % Sat.");
    chBsn = new String("F" + wvs[1] + " % Sat.");
    bgChAn = new String("B" + wvs[0] + " Median");
    bgChBn = new String("B" + wvs[1] + " Median");
  }

  /****************************************************************************
   * <b>Description: </b>
   *    find the address of the column that is interested.
   * <p><b>Parameters: </b>
   * <br> str -- a line of the file
   * <br> key -- column name to be searched
   * <br> noQuato -- column name withouth quato.
   * <P><b>Return: </b> the index of the column
   ****************************************************************************/
  private int findRightCol(String str[], String key, String noQuato){
    int addr = 0;
    int size = str.length;
    int i;
    String temp = new String("");

    for(i=0; i<str.length; i++){
      if(str[i].equalsIgnoreCase(key) || str[i].equalsIgnoreCase(noQuato)){
        addr = i;
        i = str.length;
      }
    }
    return addr;
  }

  /****************************************************************************
   *<b>Description: </b>
   *  check if a parameter is a character.
   *<p><b>Parameter: </b>
   *<br> x --- the input to be checked.
   *<p><b>Return: </b> true if the input is a character; otherwise, false.
   ****************************************************************************/
  private boolean isChar(char x){
    boolean b = true;

    switch(x) {
      case '1': case '2': case '3': case '4': case '5': case '6': case '7':
      case '8': case '9': case '0':
      b = false;
      break;

      default: b = true;
    }
    return b;
  }

  /****************************************************************************
   *<b>Description: </b>
   *  check if a input string is a number.
   *<p><b>Parameter: </b>
   *<br> x --- the input to be checked.
   *<p><b>Return: </b> true if the input is a character; otherwise, false.
   ****************************************************************************/
  private boolean isNumber(String x){
    boolean b = true;
    int length = x.length();

    for(int i=0; i<length; i++){
      if(isChar(x.charAt(i))){
        b = false;
        i = length;
      }
    }
    return b;
  }

  /****************************************************************************
   *<b>Description: </b>
   *  check if a string contains wave length information.
   *<p><b>Parameter: </b>
   *<br> str --- the input to be checked.
   *<p><b>Return: </b> true if the input contains the info; otherwise, false.
   ****************************************************************************/
  private boolean isWaveLengthDefination(String str){
    String temp = str;
    if(temp.charAt(0) == '\"' && temp.indexOf('=') > 0){
      temp = temp.substring(1, temp.indexOf('='));
      if(temp.equalsIgnoreCase(WAVE_KEY_1) || temp.equalsIgnoreCase(WAVE_KEY_2)){
        return true;
      } else {
        return false;
      }
    } else {
      return false;
    }
  }

  /*****************************************************************************
   *<b>DESCRIPTION: </b>
   *   set flag based on saturated pixels
   *<p><b>Parameters: </b>
   *<br>  tuple --- the information of one spot
   *<br>  sat --- the address of satureated pixels
   *<br>  indx --- the address of orginal flag
   *<p><b>RETRUNED: </b>  the flag
   ***************************************************************************/
  private String setFlag(String[] tuple, int sat, int indx){
    String f = new String("");
    int flagInt;
    float test, fPix, fSat;

    flagInt = Integer.parseInt(tuple[indx]);
    if(flagInt < 0){
      f = "X";
    } else {
      fPix = Float.parseFloat(tuple[fPixAddr]);
      fSat = Float.parseFloat(tuple[sat]);
      test = fPix * (1 - fSat);
      if(test < 10){
        f = "A";
      } else if (test >= 10 || test < 50){
        f = "B";
      } else {
        f = "C";
      }
    }
    return f;
  }
}