smithwaterman.java

Sequence alignement using different algorithms

package norman.baba.algorithms;

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

import norman.baba.grids.*;

/**
 * <p>Title: BABA</p>
 * <p>Description: Bioinformatique Research Project</p>
 * <p>Copyright: Copyright Norman Casagrande (c) 2003</p>
 * <p>Company: </p>
 * @author Norman Casagrande
 * @version 1.0
 */

public class SmithWaterman extends NeedlemanWunsch {

   protected static final int PHASE_SELECT_LOCAL = 2;

   protected JLabel m_l4Choiche;

   // Ridefine DrawablePanel
   protected class FourChsDrawablePanel
       extends DrawablePanel {
      public void paintComponent(Graphics g) {

         int startY;
         int verticalPos = this.getSize().height / 2 - 6;
         int width = this.getSize().width - 6;

         // /
         startY = verticalPos - 5;
         g.drawLine(4, startY, width, startY - 15);

         // //
         startY = verticalPos - 1;
         g.drawLine(4, startY, width, startY);


         // \
         startY = verticalPos + 2;
         g.drawLine(4, startY, width, startY + 15);

         // \\
         startY = verticalPos + 6;
         g.drawLine(4, startY, width, startY + 22);

      }
   }

   public SmithWaterman(JPanel contentPane,
                        String defaultString1, String defaultString2) {
      super(contentPane, defaultString1, defaultString2);
   }

   public SmithWaterman(JPanel contentPane) {
      this(contentPane, "", "");
   }

   public String getAlgorithmName() {
      return "Smith & Waterman Local Search";
   }

   protected void setEast(JPanel rightPanel) {
      super.setEast(rightPanel);

      m_l4Choiche = new JLabel("0");
      m_l4Choiche.setOpaque(true);

      putFourDrawablePanel();

      m_currStatusPanel.add(m_l4Choiche,
                            new GridBagConstraints(2, 3, 1, 1, 0.0, 0.0,
                            GridBagConstraints.WEST,
                            GridBagConstraints.NONE,
                            new Insets(0, 0, 0, 0), 0, 0));

   }

   protected void putFourDrawablePanel() {
      m_currStatusPanel.remove(m_dwPanel);
      m_dwPanel = new FourChsDrawablePanel();
      m_currStatusPanel.add(m_dwPanel,
                            new GridBagConstraints(1, 0, 1, 4, 0.0, 0.0,
          GridBagConstraints.CENTER,
          GridBagConstraints.NONE,
          new Insets(0, 0, 0, 0), 15, 50));
      m_l4Choiche.setVisible(true);
   }

   protected void putOriginalDrawablePanel() {
      m_currStatusPanel.remove(m_dwPanel);
      m_dwPanel = new DrawablePanel();
      m_currStatusPanel.add(m_dwPanel,
                            new GridBagConstraints(1, 0, 1, 4, 0.0, 0.0,
          GridBagConstraints.CENTER,
          GridBagConstraints.NONE,
          new Insets(0, 0, 0, 0), 15, 50));
      m_l4Choiche.setVisible(false);
   }

   // Default GAP scores
   protected void setDefaultGap(int whichString) {
      switch (whichString) {
         case STRING_ONE:
            this.setGapSequence(this.getGapKSequence(GAP_ONE, -1), GAP_ONE);
            break;
         case STRING_TWO:
            this.setGapSequence(this.getGapKSequence(GAP_TWO, -1), GAP_TWO);
            break;
      }
   }

   // Default TABLE scores
   protected void setDefaultScores() {

      m_scoreHash.clearScores();

      int i, j;
      char a, b;
      for (i = 0; i < m_alphabet.length(); ++i) {
         for (j = 0; j < i+1; ++j) {
            //System.out.println("A: " + m_alphabet.charAt(j) +
            //                   " - B: " + m_alphabet.charAt(i));

            a = m_alphabet.charAt(j);
            b = m_alphabet.charAt(i);

            if (a == b) {
               m_scoreHash.setScore(a, b, 2);
            }
            else {
               m_scoreHash.setScore(a, b, -1);
            }
         }
      }
   }

   protected void stepForward(boolean showSteps) {

     switch (m_currentPhase) {

        case PHASE_CALC_GRID:

           if (m_currentStep >=
               (m_dpTable.getHCellsCount() - 2) *
               (m_dpTable.getVCellsCount() - 2)) {

              // Entering backtrack phase
              m_currentPhase = PHASE_SELECT_LOCAL;

              m_dpTable.clearDPHighlights();
              m_dpTable.clearAllArrows();
              m_dpTable.clearGridCircle();
              m_lDEqual.setText("D(x, x) = Select");
              m_l1Choiche.setText("No Pointer");
              m_l2Choiche.setText("No Pointer");
              m_l3Choiche.setText("No Pointer");
              m_l1Choiche.setBackground(m_mainPane.getBackground());
              m_l2Choiche.setBackground(m_mainPane.getBackground());
              m_l3Choiche.setBackground(m_mainPane.getBackground());

              putOriginalDrawablePanel();

              this.findMaxValues();
              setInfoMessage("Select Starting local!");

              //stepFWDBackTrack(showSteps);
           }
           else {
              setInfoMessage("Calculating DP Table. Step: " +
                                  m_currentStep);
              stepFWDCalc(showSteps);
           }

           break;

        case PHASE_SELECT_LOCAL:

           this.initBackward();

        case PHASE_BACKTRACK:

           stepFWDBackTrack(showSteps);
           break;
     }

  }

  protected void stepBackward() {

     CellElement currentCell;

     switch (m_currentPhase) {

        case PHASE_CALC_GRID:

           m_currentStep--;

           if (m_currentStep <= 0) {
              stepZero();
              return;
           }

           Point realD = getCoordsByStep(m_currentStep);
           currentCell = m_dpTable.getCell(realD.x, realD.y);

           // erasing pointers
           currentCell.clearAll();
           m_currentStep--;

           stepForward(true);

           break;

        case PHASE_SELECT_LOCAL:

          putFourDrawablePanel();

           m_currentStep--;
           m_currentPhase = PHASE_CALC_GRID;
           m_dpTable.clearHighlightColors();
           m_dpTable.clearInteractiveCells();
           stepForward(true);
           break;

        case PHASE_BACKTRACK:

           currentCell = (CellElement) m_backTrackList.getLast();
           currentCell.clearColor();

           if (m_backTrackList.size() <= 1) {
              m_currentPhase = PHASE_SELECT_LOCAL;
              m_backTrackList.clear();
              m_dpTable.clearAllArrows();
              m_dpTable.clearGridCircle();
              m_dpTable.clearHighlightColors();
              m_dpTable.clearInteractiveCells();
              setInfoMessage("Select Starting local!");

              m_lDEqual.setText("D(x, x) = Select");
              m_l1Choiche.setText("No Pointer");
              m_l2Choiche.setText("No Pointer");
              m_l3Choiche.setText("No Pointer");

              this.findMaxValues();
           }
           else {

              m_backTrackList.removeLast();
              currentCell = (CellElement) m_backTrackList.getLast();
              currentCell.clearColor();

              if (m_backTrackList.size() == 0) {
                 m_backtrackLastSel = m_dpTable.getLastCell();
              }
              else {
                 m_backtrackLastSel = (CellElement) m_backTrackList.getLast();
                 m_backTrackList.removeLast();
              }

              // cut result string
              boolean toErase = false;
              for (int i = 0; i < 3; i++) {
                 if (m_resLine[i].length() > 1) {
                    m_resLine[i] = m_resLine[i].substring(2,
                        m_resLine[i].length());
                 }
                 else {
                    m_resLine[i] = "";
                    toErase = true;
                 }
              }

              if (toErase) {
                 m_bottomResultArea.setText("");
              }

              stepFWDBackTrack(true);
           }

           break;
     }

  }

  /**
   * Ovveride of stepFWDCalc.
   * Now uses scores and consider the fourth possibility 0
   * when computing D(i,j)
   */
  protected void stepFWDCalc(boolean showSteps) {

     if (m_currentStep == 0) {
        m_btnSetOne.setEnabled(false);
        m_btnSetTwo.setEnabled(false);
        m_btnSetGapOne.setEnabled(false);
        m_btnSetGapTwo.setEnabled(false);
        m_btnScoreTable.setEnabled(false);

        m_btnPrev.setEnabled(true);
        m_btnBeginning.setEnabled(true);
     }

     Point realD = getCoordsByStep(m_currentStep);