## org.biojava.bio.chromatogram
Class AbstractChromatogram

    java.lang.Object
      org.biojava.bio.chromatogram.AbstractChromatogram

All Implemented Interfaces:
  Chromatogram

Direct Known Subclasses:
  ABIFChromatogram, SCF, SimpleChromatogram

    public abstract class AbstractChromatogram

extends Object
implements Chromatogram

A basic, abstract implementation of `Chromatogram`. Provides protected setters so that subclasses may set the value of the various properties of a chromatogram. Chromatograms should be created using `ChromatogramFactory` or a parser for a particular file format.

Since:
  1.3
Author:
  Rhett Sutphin (UI CBCB), Matthew Pocock

Field Summary

Fields inherited from interface org.biojava.bio.chromatogram.Chromatogram
`DNA, OFFSETS`

Constructor Summary
`AbstractChromatogram()` Create a new AbstractChromatogram.

Method Summary
`protected void` `clearTraces()` Sets the trace data structures to null.
`protected Alignment` `createImmutableAlignment(Map labelsToSymLists)` A factory method for creating new immutable alignments, particularly for use as base call alignments.
`protected SymbolList` `createImmutableSymbolList(Alphabet alpha, List syms)` A factory method for creating new symbol lists with a given alphabet.
`Alignment` `getBaseCalls()` Return the total number of base calls.
`int` `getMax()` Gets the max intensity from all the traces.
`int` `getMax(AtomicSymbol nucleotide)` Gets the max intensity on the trace for the specified nucleotide.
`int` `getSequenceLength()` Return the sequence length.
`int` `getSignificantBits()` Return the number of significant bits.
`int[]` `getTrace(AtomicSymbol nucleotide)` Returns an array containing the intensities of the sampled waveform representing the chromatogram trace for base `nucleotide`.
`int` `getTraceLength()` Returns the length of the trace of the Chromatogram.
`protected static int[]` `reverse(int[] src)` Utility method for reversing an int[] array.
`Chromatogram` `reverseComplement()` Returns a new `Chromatogram` representing the reverse complement of this one.
`protected SymbolList` `reverseComplementBaseCallList(Object label)` Return a symbol list containing the reverse complement of the base call data for the given label.
`protected Alignment` `reverseComplementBaseCalls()` Returns a new base call alignment that is the reverse complement of one in this chromatogram.
`protected abstract AbstractChromatogram` `reverseComplementInstance()` Returns a new instance of this AbstractChromatogram subclass for use in `reverseComplement()`.
`protected void` `setBaseCallAlignment(Alignment align)` Provides the list of base calls.
`protected void` `setBits(int bits)` Sets the number of significant bits in the trace samples.
`protected void` `setTrace(AtomicSymbol nuc, int[] trace, int maxVal)` Provides the trace samples for a particular nucleotide.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### AbstractChromatogram

    public AbstractChromatogram()

  Create a new AbstractChromatogram.

Method Detail

### getTrace

    public int[] getTrace(AtomicSymbol nucleotide)
                   throws IllegalSymbolException

  Description copied from interface: `Chromatogram`
  Returns an array containing the intensities of the sampled waveform representing the chromatogram trace for base `nucleotide`. This may be a reference the actual internal representation of the samples, so callers must not modify it.

  The resulting array for each nucleotide must be `Chromatogram.getTraceLength()` `int`s long.

  Specified by:
    `getTrace` in interface `Chromatogram`
  Parameters:
    `nucleotide` - the trace to examine. Must be the symbol for A, C, G, or T as provided by `DNATools`
  Returns:
    an array of integers representing the values of a particular chromatogram trace.
  Throws:
    `IllegalSymbolException` - if `nucleotide` isn't in the DNA alphabet

### getTraceLength

    public int getTraceLength()

  Description copied from interface: `Chromatogram`
  Returns the length of the trace of the Chromatogram.

  Specified by:
    `getTraceLength` in interface `Chromatogram`
  Returns:
    the number of samples in the trace
  See Also:
    `Chromatogram.getTrace(AtomicSymbol)`

### getMax

    public int getMax()

  Description copied from interface: `Chromatogram`
  Gets the max intensity from all the traces. Must be equivalent to the max of calling `Chromatogram.getMax(AtomicSymbol)` on each of the four non-ambiguous DNA nucleotides.

  Specified by:
    `getMax` in interface `Chromatogram`
  Returns:
    the max intensity

### getMax

    public int getMax(AtomicSymbol nucleotide)
               throws IllegalSymbolException

  Description copied from interface: `Chromatogram`
  Gets the max intensity on the trace for the specified nucleotide.

  Specified by:
    `getMax` in interface `Chromatogram`
  Parameters:
    `nucleotide` - the trace to examine. Must be a concrete (non-ambiguous) nucleotide from the DNA alphabet
  Returns:
    the max intensity
  Throws:
    `IllegalSymbolException` - when the nucleotide isn't from the DNA alphabet

### getBaseCalls

    public Alignment getBaseCalls()

  Return the total number of base calls.

  Specified by:
    `getBaseCalls` in interface `Chromatogram`
  Returns:
    the total number of base calls

### getSequenceLength

    public int getSequenceLength()

  Return the sequence length.

  Specified by:
    `getSequenceLength` in interface `Chromatogram`
  Returns:
    the sequence length

### getSignificantBits

    public int getSignificantBits()

  Return the number of significant bits.

  Specified by:
    `getSignificantBits` in interface `Chromatogram`
  Returns:
    the significant bits

### setBaseCallAlignment

    protected final void setBaseCallAlignment(Alignment align)
                                       throws IllegalAlphabetException,
                                              IllegalArgumentException,
                                              NoSuchElementException

  Provides the list of base calls.

  Parameters:
    `align` - the base call alignment
  Throws:
    `NoSuchElementException` - when align doesn't contain alignments with the required DNA and OFFSETS labels
    `IllegalArgumentException` - the lists in align aren't all the same length.
    `IllegalAlphabetException` - if the required lists don't have the correct alphabets. See the documentation of `Chromatogram.getBaseCalls()` for details.
  See Also:
    `Chromatogram.getBaseCalls()`

### clearTraces

    protected final void clearTraces()

  Sets the trace data structures to null. If a subclass needs to replace the traces with new traces of a different length, this method must be called first to avoid provoking an IllegalArgumentException from setTrace due to a length mismatch.

### setTrace

    protected final void setTrace(AtomicSymbol nuc,
                                  int[] trace,
                                  int maxVal)
                           throws IllegalArgumentException,
                                  IllegalSymbolException

  Provides the trace samples for a particular nucleotide.

  Parameters:
    `nuc` - A DNA nucleotide
    `trace` - the trace samples themselves
    `maxVal` - the maximum value in the trace array. If this value is `Integer.MIN_VALUE`, this method will do a linear search of trace to determine the max.
  Throws:
    `IllegalArgumentException` - when trace.length is different from any of the existing (non-null) traces
    `IllegalSymbolException` - when nuc is not a concrete DNA nucleotide

### setBits

    protected final void setBits(int bits)
                          throws IllegalArgumentException

  Sets the number of significant bits in the trace samples.

  Parameters:
    `bits` - a non-negative integer indicating the number of significant bits in each trace sample
  Throws:
    `IllegalArgumentException` - when `bits` is negative

### reverseComplementInstance

    protected abstract AbstractChromatogram reverseComplementInstance()

  Returns a new instance of this AbstractChromatogram subclass for use in `reverseComplement()`.

  Returns:
    a reverse-complemented AbstractChromatogram

### reverseComplement

    public Chromatogram reverseComplement()

  Description copied from interface: `Chromatogram`
  Returns a new `Chromatogram` representing the reverse complement of this one.

  Implementors should copy the metadata about the chromatogram (i.e., base calls) as is appropriate to their formats.

  Specified by:
    `reverseComplement` in interface `Chromatogram`
  Returns:
    a new chromatogram that is the reverse complement of this one

### reverseComplementBaseCalls

    protected Alignment reverseComplementBaseCalls()

  Returns a new base call alignment that is the reverse complement of one in this chromatogram. This is achieved by calling `reverseComplementBaseCallList(java.lang.Object)` for each label in the current base call alignment. When that method returns null, no list will appear in reverse complement base call alignment with the null-provoking label. For this reason, subclasses are encouraged to override `reverseComplementBaseCallList(java.lang.Object)` to handle any additional per-base metadata that they store.

  This implementation should be safely inheritable for all chromatogram implementations, unless one just doesn't want base calls on its reverse complement output. If this is the case, it should override this method to return null.

  Returns:
    a new `Alignment` that is the reverse complement of the one in the current chromatogram

### reverseComplementBaseCallList

    protected SymbolList reverseComplementBaseCallList(Object label)

  Return a symbol list containing the reverse complement of the base call data for the given label. The returned list will be stored in the reverse complement's base call alignment under the same label.

  Implementation note: subclasses which do not use an `IntegerAlphabet` for their offsets lists must override this method, at least for the case where `label == `Chromatogram.OFFSETS``.

  Parameters:
    `label` - the label Object
  Returns:
    an appropriately reverse-complemented SymbolList, or null if the label is unhandled.

### createImmutableSymbolList

    protected SymbolList createImmutableSymbolList(Alphabet alpha,
                                                   List syms)
                                            throws IllegalSymbolException,
                                                   ClassCastException

  A factory method for creating new symbol lists with a given alphabet. The default implementation should be fine for nearly all cases, but the option is given in case a developer wishes to use a more memory efficient implementation.

  Parameters:
    `alpha` - the `Alphabet` for the new list
    `syms` - the symbols to put in the new list
  Returns:
    a new immutable SymbolList containing all the given symbols using the given Alphabet
  Throws:
    `IllegalSymbolException` - when alpha and syms are incompatible
    `ClassCastException` - when any object in syms isn't a Symbol

### createImmutableAlignment

    protected Alignment createImmutableAlignment(Map labelsToSymLists)
                                          throws IllegalArgumentException,
                                                 ClassCastException

  A factory method for creating new immutable alignments, particularly for use as base call alignments. The default implementation should be fine for nearly all cases.

  Parameters:
    `labelsToSymLists` - a `Map` whose keys are desired labels for the alignment and whose values are the SymbolLists. All the SymbolLists must be the same length.
  Returns:
    a new Alignment
  Throws:
    `IllegalArgumentException` - if the lists aren't all the same length
    `ClassCastException` - if any of the values in the map aren't SymbolLists

### reverse

    protected static final int[] reverse(int[] src)

  Utility method for reversing an int[] array. Visible for subclass use.

  Parameters:
    `src` - the source array
  Returns:
    an array of the same length containing all values in src in reverse order