UserDataAlgorithm.java

/* UserDataAlgorithm.java
 *
 * created: Wed May 10 2000
 *
 * This file is part of Artemis
 *
 * Copyright (C) 2000  Genome Research Limited
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Header: //tmp/pathsoft/artemis/uk/ac/sanger/artemis/plot/UserDataAlgorithm.java,v 1.6 2008-10-30 17:18:28 tjc Exp $
 */

package uk.ac.sanger.artemis.plot;

import uk.ac.sanger.artemis.sequence.*;

import uk.ac.sanger.artemis.util.*;
import uk.ac.sanger.artemis.io.ReadFormatException;

import java.io.*;
import java.util.regex.Pattern;

/**
 *  Objects of this class have one useful method - getValues (), which takes a
 *  range of bases and returns a single floating point number.  The number is
 *  calculated by averaging the values from a data file.  The Strand to use is
 *  set in the constructor.
 *
 *  @author Kim Rutherford <kmr@sanger.ac.uk>
 *  @version $Id: UserDataAlgorithm.java,v 1.6 2008-10-30 17:18:28 tjc Exp $
 **/

public class UserDataAlgorithm extends BaseAlgorithm
{
  /**
   *  The data that was read by the constructor.
   **/
  private float data[][] = null;

  /**
   *  The maximum value in the data array.
   **/
  private float data_max = Float.MIN_VALUE;

  /**
   *  The minimum value in the data array.
   **/
  private float data_min = Float.MAX_VALUE;

  /**
   *  The average calculated by readData ().
   **/
  private float average_value = 0;

  /**
   *  The value returned by getValueCount ().
   **/
  private int number_of_values;
  
  private boolean logTransform;
  
  /**
   *  Create a new UserDataAlgorithm object.
   *  @param strand The strand to do the calculation on.
   *  @param document The Document to read the data from.
   **/
  public UserDataAlgorithm (final Strand strand, final Document document, 
                            final boolean logTransform)
      throws IOException 
  {
    super (strand, "User algorithm from " + document.getName (), "user");

    this.logTransform = logTransform;
    final Reader document_reader = document.getReader ();

    LinePushBackReader pushback_reader = new LinePushBackReader (document_reader);

    final String first_line = pushback_reader.readLine ();
    final StringVector tokens = StringVector.getStrings (first_line, " ");

    if (tokens.size () < 1) 
      throw new ReadFormatException ("unknown file type");

    this.number_of_values = tokens.size ();
    pushback_reader.pushBack (first_line);
    data = new float [strand.getSequenceLength ()][tokens.size ()];

    readData (pushback_reader);
    pushback_reader.close();
  }

  /**
   *  Read all from buffered_reader into data.
   **/
  private void readData (final LinePushBackReader pushback_reader)
      throws IOException
  {
    String line = null;
    int count = 0;
    final int seqLength = getStrand ().getSequenceLength ();
    final Pattern patt = Pattern.compile("\\s+");
    
    while ((line = pushback_reader.readLine ()) != null)
    {
      if (count >= seqLength) 
        throw new ReadFormatException ("too many values in input file");

      //final StringVector tokens = StringVector.getStrings (line, " ");

      String tokens[] = patt.split(line); //line.split("\\s+");  
      if (tokens.length == data[0].length) 
      {
        for (int i = 0 ; i < tokens.length ; ++i)
        {
          try 
          {
            float value = Float.parseFloat(tokens[i]);
              //Float.valueOf ((String)tokens.elementAt (i)).floatValue ();

            if(logTransform)
              value = (float) Math.log(value+1);
            
            if (value > data_max) 
              data_max = value;

            if (value < data_min)
              data_min = value;

            data[count][i] = value;

            average_value += value;
          } 
          catch (NumberFormatException e) 
          {
            throw new ReadFormatException ("cannot understand this number: " +
                                           tokens[i] + " - " +
                                           e.getMessage ());
          }
        }
      } 
      else 
        throw new ReadFormatException ("line has the wrong number of fields:\n"+line);

      ++count;
    }

    average_value /= data[0].length * seqLength;
  }

  /**
   *  Return the value of the function between a pair of bases.
   *  @param start The start base (included in the range).
   *  @param end The end base (included in the range).
   *  @param values The one return value for this algorithm is returned in
   *    this array.
   **/
  public void getValues (int start, int end, final float [] values) 
  {
    final int value_count = getValueCount ();

    for (int i = 0 ; i < value_count ; ++i) 
    {
      values [i] = 0;
      for (int base = start ; base <= end ; ++base) 
        values [i] += data[base - 1][i] / (end - start + 1);
    }
  }

  /**
   *  Return the number of values a call to getValues () will return - one
   *  in this case.
   **/
  public int getValueCount () 
  {
    return number_of_values;
  }

  /**
   *  Return the default or optimal window size.
   *  @return null is returned if this algorithm doesn't have optimal window
   *    size.
   **/
  public Integer getDefaultWindowSize () 
  {
    return new Integer (3);
  }

  /**
   *  Return the default maximum window size for this algorithm.
   *  @return null is returned if this algorithm doesn't have maximum window
   *    size.
   **/
  public Integer getDefaultMaxWindowSize ()
  {
    return new Integer (100);
  }

  /**
   *  Return the default minimum window size for this algorithm.
   *  @return null is returned if this algorithm doesn't have minimum window
   *    size.
   **/
  public Integer getDefaultMinWindowSize () 
  {
    return new Integer (1);
  }

  /**
   *  Return the default or optimal step size.
   *  @return null is returned if this algorithm doesn't have optimal step
   *    size.
   **/
  public Integer getDefaultStepSize (int window_size)
  {
    if (window_size > 10) 
      return new Integer (window_size / 10);
    else 
      return null;
  }

  /**
   *  Return the maximum value of this algorithm.
   **/
  protected Float getMaximumInternal ()
  {
    return new Float (data_max);
  }

  /**
   *  Return the minimum value of this algorithm.
   **/
  protected Float getMinimumInternal () 
  {
    return new Float (data_min);
  }

  /**
   *  Return the average value of function over the whole strand.
   **/
  public Float getAverage () 
  {
    return new Float (average_value);
  }

}