/***************************************************************************
 * Author:  Jianwei(Jerry) Li.
 * Name:  ScanArrayMev (Version 1.0)
 * Date:  Created: 04/07/2002 and modified: 04/07/2002
 * Descp: A Java class that reads a ScanArray file and write it as a .mev file
 ***************************************************************************/

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 ScanArrayMev extends MevConverter implements MevAttributes{

  private JFrame parent;
  private boolean gSwap;
  private String bgChA, bgChB;
  private String chA, chB;
  private String chApixel, chBpixel;
  private String inFileNamePath;
  private String mevFileName;
  private String barTitle;
  private int areaPixel;  // area in pixels
  private int quantWay;
  private int gAnnType;

  private final int TOTAL = 0;
  private final int MEAN = 1;
  private final int MODE = 2;
  private final int MEDIAN = 3;

  private final String ARRAY_ROW = "Array Row";
  private final String ARRAY_COL = "Array Column";
  private final String BEGIN_DATA = "Begin Data";
  private final String COLUMN = "Column";
  private final String END_DATA = "End Data";
  private final String NAME = "Name";
  private final String RW = "Row";
  private final String INTENSITY = "Intensity";
  private final String BKG = "Background";
  private final String AREA = "Area";

  private final String TAB = "\t";
  private final String PAN = "#";

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> sfName --- the name of ScanArray file to be converted.
   *<br> tfName --- the name of .tav file that is an output.
   *<br> way -- the protocol to generate the intensity in ScanArray file.
   *<br> title -- the string showed on the window bar.
   *****************************************************************************/
  public ScanArrayMev(String sfName, String tfName, int way, String title) {
    super();
    inFileNames = new Vector(1);
    outFileNames = new Vector(1);
    inFileNames.add(sfName);
    outFileNames.add(tfName);
    gSwap = false;
    quantWay = way;
    barTitle = title;
  }

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> sfNames --- the names of ScanArray files to be converted.
   *<br> tfNames --- the names of mev files that is an output.
   *<br> way -- the protocol to generate the intensity in ScanArray file.
   *<br> title -- the string showed on the window bar.
   *<br> annNum --- the ann file type, one for one / many for one.
   *****************************************************************************/
  public ScanArrayMev(JFrame p, Vector sfNames, Vector tfNames, int way, String title,
                      int annNum) {
    super();
    parent = p;
    inFileNames = sfNames;
    outFileNames = tfNames;
    quantWay = way;
    gSwap = false;
    barTitle = title;
    gAnnType = annNum;
  }

  public void needSwapChannels(boolean b) { gSwap = b; }

  /***************************************************************************
   * <b>Description: </b>
   *   overrides an abstract method to implement the main function of class.
   **************************************************************************/
  public void run () {
    boolean noError;
    String aLine = new String("");
    String densA = new String("");
    String densB = new String("");
    String bgA = new String("");  // background info for channel A
    String bgB = new String("");  // background info for channel B
    String medA = new String("null");
    String medB = new String("null");
    String annoFileNamePath;
    String scanArrayFileName;
    String colValues[];
    String extraInfo = new String("");
    String colNames[];
    String channels[] = {"ch1", "ch2"};
    String dataStart[], dataEnd[];
    String annoFile[] = null;
    String mevFileHeader[];
    StringBuffer mevLine = new StringBuffer(200);
    int numOfFiles;
    int hLines;    // the index of  header of data section
    int lastLine;  // the index of last line of data
    int max = 0;
    int maxRow = 0;
    int maxCol = 0;
    int maxArrayRow = 0;  // meta row
    int maxArrayCol = 0;  // meta column
    int row, col, metaRow, metaCol, slideRow, slideCol;
    int i, j, k, flagInt, arrayRowIndex, arrayColIndex, colIndex, rowIndex, nameIndex;
    int ch1IntenLoc, ch1Bkg, ch1AreaLoc, ch2IntenLoc, ch2Bkg, ch2AreaLoc;
    int spAreaA, spAreaB;
    int numSpot;
    Vector scanArrayFile;
    BufferedWriter mevWriter = null;
    BufferedWriter annoWriter = null;
    FileOutputStream mevFileOut = null;
    FileReading fileReader;

    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)outFileNames.elementAt(i);
      try {
        fileReader = new FileReading(inFileNamePath);

        if(fileReader.done){
          scanArrayFile = fileReader.getFileContentInLines();
        } else {
          setErrorMessage(fileReader.getProcessMessage());
          taskEnd = 1;
          counter = 1;
          return;
        }
      } catch (IOException e){
        setErrorMessage(e.getMessage());
        taskEnd = 1;
        counter = 1;
        return;
      }

        // find the data section in the ScanArray file
      dataStart = getValueAndIndex(scanArrayFile, BEGIN_DATA);
      dataEnd = getValueAndIndex(scanArrayFile, END_DATA);
      if(dataStart[0] == null){
        setErrorMessage(IOUtil.extractFileNameFromPath(inFileNamePath) + " might be saved as Unicode file. "
          + "Please save it as ASCII text and try again.\n");
        //taskEnd = 1;
        //counter = 1;
        return;
      }
      hLines = Integer.parseInt(dataStart[1]) + 1;
      lastLine = Integer.parseInt(dataEnd[1]) - 1;
      numSpot = lastLine - hLines;

      aLine = (String)scanArrayFile.elementAt(hLines);
      defineKeys(channels);
      colNames = separateLine(aLine);

        // find the locations of required columns of data
      arrayRowIndex = findRightCol(colNames, ARRAY_ROW);
      arrayColIndex = findRightCol(colNames, ARRAY_COL);
      colIndex = findRightCol(colNames, COLUMN);
      rowIndex = findRightCol(colNames, RW);
      ch1AreaLoc = findRightCol(colNames, chApixel);
      ch2AreaLoc = findRightCol(colNames, chBpixel);

      aLine = (String)scanArrayFile.elementAt(lastLine);

      colValues = separateLine(aLine);

      if(colValues.length > 2){
        maxArrayRow = Integer.parseInt(colValues[arrayRowIndex]);
        maxArrayCol = Integer.parseInt(colValues[arrayColIndex]);
        maxCol = Integer.parseInt(colValues[colIndex]);
        maxRow = Integer.parseInt(colValues[rowIndex]);
        max = maxArrayRow * maxArrayCol;
      } else {
        JOptionPane.showMessageDialog(parent,
          "You might add extra space at the end of file.\nPlease "
          + "remove it and try again.", parent.getTitle(), JOptionPane.ERROR_MESSAGE);
        noError = false;
        counter += numOfFiles;
      }

      if(noError){
          // check if the original file has been modified.
        if((max * maxCol * maxRow) != numSpot){
          JOptionPane.showMessageDialog(parent,
            "You might have dropped some of your spots.\nThe converter "
            + "requires an original ScanArray file.", parent.getTitle(),
            JOptionPane.ERROR_MESSAGE);
          noError = false;
          counter += numOfFiles;
        }

        if(noError){
          ch1IntenLoc = findRightCol(colNames, chA);
          ch1Bkg = findRightCol(colNames, bgChA);

          ch2IntenLoc = findRightCol(colNames, chB);
          ch2Bkg = findRightCol(colNames, bgChB);

          nameIndex = findRightCol(colNames, NAME);

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

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

             sortKeys = new int[NUM_SORT][numSpot];
             outFile = new String[numSpot];
             scanArrayFileName = IOUtil.extractFileNameFromPath(inFileNamePath);

             // generate MEV file header
             mevFileHeader = generateHeader(scanArrayFileName, numSpot, true);

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

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

             counter += hLines;
             int unid = 1;
             for(j = hLines + 1, k=0; j<=lastLine; j++, k++){
               aLine = (String)scanArrayFile.elementAt(j);
               colValues = separateLine(aLine);

               metaRow = Integer.parseInt(colValues[arrayRowIndex]);
               metaCol = Integer.parseInt(colValues[arrayColIndex]);
               col = Integer.parseInt(colValues[colIndex]);
               row = Integer.parseInt(colValues[rowIndex]);

                  // channel A is always for Cy3 and B for Cy5 in .tav file
               if(gSwap){
                 spAreaA = calculateSpotArea(colValues, ch2AreaLoc);
                 spAreaB = calculateSpotArea(colValues, ch1AreaLoc);
                 bgA = calculateBackground(colValues, ch2Bkg);
                 bgB = calculateBackground(colValues, ch1Bkg);
                 if(quantWay != TOTAL){
                   if(gBkgCorrect){
                     densA = calculateIntegrateIntensity(colValues, ch2IntenLoc,
                       ch2Bkg, ch2AreaLoc, true);
                     densB = calculateIntegrateIntensity(colValues, ch1IntenLoc,
                       ch1Bkg, ch1AreaLoc, true);
                     if(quantWay == MEDIAN){
                       medA = calculateMedianIntensity(colValues, ch2IntenLoc, ch2Bkg, true);
                       medB = calculateMedianIntensity(colValues, ch1IntenLoc, ch1Bkg, true);
                     }
                   } else {
                     densA = calculateIntegrateIntensity(colValues, ch2IntenLoc,
                       ch2Bkg, ch2AreaLoc, false);
                     densB = calculateIntegrateIntensity(colValues, ch1IntenLoc,
                       ch1Bkg, ch1AreaLoc, false);
                     if(quantWay == MEDIAN){
                       medA = calculateMedianIntensity(colValues, ch2IntenLoc, ch2Bkg, false);
                       medB = calculateMedianIntensity(colValues, ch1IntenLoc, ch1Bkg, false);
                     }
                   }
                 } else {
                   // because the original data contains no median intensity, it
                   // is not necessary to convert it.
                   if(gBkgCorrect){
                     densA = calculateIntegrateIntensity(colValues, ch2IntenLoc,
                       ch2Bkg, true);
                     densB = calculateIntegrateIntensity(colValues, ch1IntenLoc,
                       ch1Bkg, true);
                   } else {
                     densA = calculateIntegrateIntensity(colValues, ch2IntenLoc,
                       ch2Bkg, false);
                     densB = calculateIntegrateIntensity(colValues, ch1IntenLoc,
                       ch1Bkg, false);
                   }
                 }
               } else {
                 spAreaA = calculateSpotArea(colValues, ch1AreaLoc);
                 spAreaB = calculateSpotArea(colValues, ch2AreaLoc);
                 bgA = calculateBackground(colValues, ch1Bkg);
                 bgB = calculateBackground(colValues, ch2Bkg);
                 if(quantWay != TOTAL){
                   if(gBkgCorrect){
                     densA = calculateIntegrateIntensity(colValues, ch1IntenLoc,
                       ch1Bkg, ch1AreaLoc, true);
                     densB = calculateIntegrateIntensity(colValues, ch2IntenLoc,
                       ch2Bkg, ch2AreaLoc, true);
                     if(quantWay == MEDIAN){
                       medA = calculateMedianIntensity(colValues, ch1IntenLoc, ch1Bkg, true);
                       medB = calculateMedianIntensity(colValues, ch2IntenLoc, ch2Bkg, true);
                     }
                   } else {
                     densA = calculateIntegrateIntensity(colValues, ch1IntenLoc,
                       ch1Bkg, ch1AreaLoc, false);
                     densB = calculateIntegrateIntensity(colValues, ch2IntenLoc,
                       ch2Bkg, ch2AreaLoc, false);
                     if(quantWay == MEDIAN){
                       medA = calculateMedianIntensity(colValues, ch1IntenLoc, ch1Bkg, false);
                       medB = calculateMedianIntensity(colValues, ch2IntenLoc, ch2Bkg, false);
                     }
                   }
                 } else {
                   // because the original data contains no median intensity, it
                   // is not necessary to convert it.
                   if(gBkgCorrect){
                     densA = calculateIntegrateIntensity(colValues, ch1IntenLoc,
                       ch1Bkg, true);
                     densB = calculateIntegrateIntensity(colValues, ch2IntenLoc,
                       ch2Bkg, true);
                   } else {
                     densA = calculateIntegrateIntensity(colValues, ch1IntenLoc,
                       ch1Bkg, false);
                     densB = calculateIntegrateIntensity(colValues, ch2IntenLoc,
                       ch2Bkg, false);
                   }
                 }
               } // end of swap testing

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

               mevLine.append(unid).append(TAB);

               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(spAreaA);
               mevLine.append(TAB).append(spAreaB).append(TAB).append(aLine);

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

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

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

               counter++;
               unid++;
             }

             if(wantSort){
               sorted = sortRowCol(maxArrayCol, 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;
            System.out.println("Error in writing file: " + ie.getMessage());
            msg += "**********\n";
            msg += "Error in writing file: " + ie.getMessage() + "\n";
          }
        }
      }
    } // end of the for loop for each file
    ready = true;
    counter = taskEnd;
  }

  /****************************************************************************
   * <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[areaPixel]);
      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 to calculate background;\n";
      msg += "and the background was set to null.\n";
    }
    return bg;
  }

  /****************************************************************************
   * <b>Descriqption: </b>
   *   calculate integrate density 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 calculateIntegrateIntensity(String[] tuple, int med, int backg,
                                             boolean bgSub){
    float fMedian, bMedian, temp;
    String den = new String("");

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

      if(bgSub){
        den += (int)(fMedian - bMedian);
      } else {
        den += (int)fMedian;
      }
    } 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 integrate density 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> areaIndx -- the address for spot area column.
   * <br> bgSub -- indicate if an intensity should subtract backgroud.
   * <p><b>Return: </b> the density
   ***************************************************************************/
  private String calculateIntegrateIntensity(String[] tuple, int med, int backg,
                                             int areaIndx, boolean bgSub){
    float fMedian, bMedian, fPix, temp;
    String den = new String("");

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

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

      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>
   *   calculate median density 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;
    String den = new String("");

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

      if(bgSub){
        den += (int)(fMedian - bMedian);
      } else {
        den += (int)fMedian;
      }
    } 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 spot area in the number of pixels.
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> areaIndx -- address for spot area.
   * <p><b>Return: </b> the area.
   ***************************************************************************/
  private int calculateSpotArea(String[] tuple, int areaIndx){
    float area;
    int temp;
    area = Float.parseFloat(tuple[areaIndx]);
    area = area / 100;
    temp = (int) area;
    return temp;
  }

  /****************************************************************************
   * <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 + barTitle);
    tempHeader[4] = new String(PAN + SPACE + ROW_COUNT + COLON + numRow);
    tempHeader[5] = new String(PAN + " converted from ScanArray 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 +
          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 +
          SAA + TAB + SAB + TAB + MEDA + TAB + MEDB;
      }
    } else {
      tempHeader[6] = UID + TAB + R + TAB + C + TAB + NAME;
    }
   return tempHeader;
  }

  /*****************************************************************************
   *<b>Description: </b>
   *   retrieve a value from the ScanArray file base on the passed key.
   *<p><b>Parameter: </b>
   *<br>  fileCont --- whole content of file.
   *<br>  key --- to match the wanted value.
   *<p><b>Return: </b>  the value and its line number (address) in the file.
   ***************************************************************************/
  private String[] getValueAndIndex(Vector fileCont, String key){
    StringTokenizer token = null;
    int size = fileCont.size();
    String temp = new String("");
    String wantKey = new String("");
    String value[] = new String[2];

    for(int i=0; i<size; i++){
      temp = (String)fileCont.elementAt(i);
      if(!temp.equals("")){
        if(isChar(temp.charAt(0))){
          token = new StringTokenizer(temp, "\t");
          wantKey = token.nextToken();
          if(wantKey.equalsIgnoreCase(key)){
            value[0] = new String(MyIni.removeEndSpace(wantKey));
            value[1] = "" + i;
            i = size;
          }
        }
      }
    }
    return value;
  }

  /**************************************************************************
   * <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> chs --- the names of channels.
   ***************************************************************************/
  private void defineKeys(String[] chs) {
    chA = new String(chs[0] + " " + INTENSITY);
    chB = new String(chs[1] + " " + INTENSITY);
    chApixel = new String(chs[0] + " " + AREA);
    chBpixel = new String(chs[1] + " " + AREA);
    bgChA = new String(chs[0] + " " + BKG);
    bgChB = new String(chs[1] + " " + BKG);
  }

  /****************************************************************************
   * <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
   * <P><b>Return: </b> the index of the column
   ****************************************************************************/
  private int findRightCol(String str[], String key){
    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)){
        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;
  }
}