src/jalview/gui/RedundancyPanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.gui;
  22
  23 import jalview.analysis.AlignSeq;
  24 import jalview.commands.CommandI;
  25 import jalview.commands.EditCommand;
  26 import jalview.commands.EditCommand.Action;
  27 import jalview.datamodel.SequenceGroup;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.jbgui.GSliderPanel;
  30 import jalview.util.MessageManager;
  31
  32 import java.awt.event.ActionEvent;
  33 import java.util.ArrayList;
  34 import java.util.List;
  35 import java.util.Stack;
  36 import java.util.Vector;
  37
  38 import javax.swing.JInternalFrame;
  39 import javax.swing.JProgressBar;
  40 import javax.swing.event.ChangeEvent;
  41 import javax.swing.event.ChangeListener;
  42 import javax.swing.event.InternalFrameAdapter;
  43 import javax.swing.event.InternalFrameEvent;
  44
  45 /**
  46  * DOCUMENT ME!
  47  *
  48  * @author $author$
  49  * @version $Revision$
  50  */
  51 public class RedundancyPanel extends GSliderPanel implements Runnable
  52 {
  53   AlignFrame af;
  54
  55   AlignmentPanel ap;
  56
  57   Stack<CommandI> historyList = new Stack<CommandI>();
  58
  59   // simpler than synching with alignFrame.
  60
  61   float[] redundancy;
  62
  63   SequenceI[] originalSequences;
  64
  65   JInternalFrame frame;
  66
  67   Vector redundantSeqs;
  68
  69   /**
  70    * Creates a new RedundancyPanel object.
  71    *
  72    * @param ap
  73    *          DOCUMENT ME!
  74    * @param af
  75    *          DOCUMENT ME!
  76    */
  77   public RedundancyPanel(final AlignmentPanel ap, AlignFrame af)
  78   {
  79     this.ap = ap;
  80     this.af = af;
  81     redundantSeqs = new Vector();
  82
  83     slider.addChangeListener(new ChangeListener()
  84     {
  85       @Override
  86       public void stateChanged(ChangeEvent evt)
  87       {
  88         valueField.setText(slider.getValue() + "");
  89         sliderValueChanged();
  90       }
  91     });
  92
  93     applyButton.setText(MessageManager.getString("action.remove"));
  94     allGroupsCheck.setVisible(false);
  95     slider.setMinimum(0);
  96     slider.setMaximum(100);
  97     slider.setValue(100);
  98
  99     Thread worker = new Thread(this);
 100     worker.start();
 101
 102     frame = new JInternalFrame();
 103     frame.setContentPane(this);
 104     Desktop.addInternalFrame(frame,
 105             MessageManager
 106                     .getString("label.redundancy_threshold_selection"),
 107             400, 100, false);
 108     frame.addInternalFrameListener(new InternalFrameAdapter()
 109     {
 110       @Override
 111       public void internalFrameClosing(InternalFrameEvent evt)
 112       {
 113         ap.getIdPanel().getIdCanvas().setHighlighted(null);
 114       }
 115     });
 116
 117   }
 118
 119   /**
 120    * This is a copy of remove redundancy in jalivew.datamodel.Alignment except
 121    * we dont want to remove redundancy, just calculate once so we can use the
 122    * slider to dynamically hide redundant sequences
 123    *
 124    * @param threshold
 125    *          DOCUMENT ME!
 126    * @param sel
 127    *          DOCUMENT ME!
 128    *
 129    * @return DOCUMENT ME!
 130    */
 131   @Override
 132   public void run()
 133   {
 134     JProgressBar progress = new JProgressBar();
 135     progress.setIndeterminate(true);
 136     southPanel.add(progress, java.awt.BorderLayout.SOUTH);
 137
 138     label.setText(MessageManager.getString("label.calculating"));
 139
 140     slider.setVisible(false);
 141     applyButton.setEnabled(false);
 142     valueField.setVisible(false);
 143
 144     validate();
 145
 146     String[] omitHidden = null;
 147
 148     SequenceGroup sg = ap.av.getSelectionGroup();
 149     int height;
 150
 151     int start, end;
 152
 153     if ((sg != null) && (sg.getSize() >= 1))
 154     {
 155       originalSequences = sg.getSequencesInOrder(ap.av.getAlignment());
 156       start = sg.getStartRes();
 157       end = sg.getEndRes();
 158     }
 159     else
 160     {
 161       originalSequences = ap.av.getAlignment().getSequencesArray();
 162       start = 0;
 163       end = ap.av.getAlignment().getWidth();
 164     }
 165
 166     height = originalSequences.length;
 167     if (ap.av.hasHiddenColumns())
 168     {
 169       omitHidden = ap.av.getViewAsString(sg != null);
 170     }
 171     redundancy = AlignSeq.computeRedundancyMatrix(originalSequences,
 172             omitHidden, start, end, false);
 173
 174     progress.setIndeterminate(false);
 175     progress.setVisible(false);
 176     progress = null;
 177
 178     label.setText(
 179             MessageManager.getString("label.enter_redundancy_threshold"));
 180     slider.setVisible(true);
 181     applyButton.setEnabled(true);
 182     valueField.setVisible(true);
 183
 184     validate();
 185     sliderValueChanged();
 186     // System.out.println((System.currentTimeMillis()-start));
 187   }
 188
 189   void sliderValueChanged()
 190   {
 191     if (redundancy == null)
 192     {
 193       return;
 194     }
 195
 196     float value = slider.getValue();
 197     List<SequenceI> redundantSequences = new ArrayList<SequenceI>();
 198     for (int i = 0; i < redundancy.length; i++)
 199     {
 200       if (value <= redundancy[i])
 201       {
 202         redundantSequences.add(originalSequences[i]);
 203       }
 204     }
 205     ap.getIdPanel().getIdCanvas().setHighlighted(redundantSequences);
 206   }
 207
 208   /**
 209    * DOCUMENT ME!
 210    *
 211    * @param e
 212    *          DOCUMENT ME!
 213    */
 214   @Override
 215   public void applyButton_actionPerformed(ActionEvent e)
 216   {
 217     Vector del = new Vector();
 218
 219     undoButton.setEnabled(true);
 220
 221     float value = slider.getValue();
 222     SequenceGroup sg = ap.av.getSelectionGroup();
 223
 224     for (int i = 0; i < redundancy.length; i++)
 225     {
 226       if (value <= redundancy[i])
 227       {
 228         del.addElement(originalSequences[i]);
 229       }
 230     }
 231
 232     // This has to be done before the restoreHistoryItem method of alignFrame
 233     // will
 234     // actually restore these sequences.
 235     if (del.size() > 0)
 236     {
 237       SequenceI[] deleted = new SequenceI[del.size()];
 238
 239       int width = 0;
 240       for (int i = 0; i < del.size(); i++)
 241       {
 242         deleted[i] = (SequenceI) del.elementAt(i);
 243         if (deleted[i].getLength() > width)
 244         {
 245           width = deleted[i].getLength();
 246         }
 247       }
 248
 249       EditCommand cut = new EditCommand(
 250               MessageManager.getString("action.remove_redundancy"),
 251               Action.CUT, deleted, 0, width, ap.av.getAlignment());
 252
 253       for (int i = 0; i < del.size(); i++)
 254       {
 255         ap.av.getAlignment().deleteSequence(deleted[i]);
 256         if (sg != null)
 257         {
 258           sg.deleteSequence(deleted[i], false);
 259         }
 260       }
 261
 262       historyList.push(cut);
 263
 264       ap.alignFrame.addHistoryItem(cut);
 265
 266       PaintRefresher.Refresh(this, ap.av.getSequenceSetId(), true, true);
 267       ap.av.firePropertyChange("alignment", null,
 268               ap.av.getAlignment().getSequences());
 269     }
 270
 271   }
 272
 273   /**
 274    * DOCUMENT ME!
 275    *
 276    * @param e
 277    *          DOCUMENT ME!
 278    */
 279   @Override
 280   public void undoButton_actionPerformed(ActionEvent e)
 281   {
 282     if (historyList == null || historyList.isEmpty())
 283     {
 284       undoButton.setEnabled(false);
 285       return;
 286     }
 287
 288     CommandI command = historyList.pop();
 289     if (ap.av.getHistoryList().contains(command))
 290     {
 291       command.undoCommand(af.getViewAlignments());
 292       ap.av.getHistoryList().remove(command);
 293       ap.av.firePropertyChange("alignment", null,
 294               ap.av.getAlignment().getSequences());
 295       af.updateEditMenuBar();
 296     }
 297
 298     ap.paintAlignment(true);
 299
 300     if (historyList.size() == 0)
 301     {
 302       undoButton.setEnabled(false);
 303     }
 304   }
 305
 306 }