src/jalview/datamodel/HiddenSequences.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
   3  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
   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 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.datamodel;
  19
  20 import java.util.*;
  21
  22 public class HiddenSequences
  23 {
  24   /**
  25    * holds a list of hidden sequences associated with an alignment.
  26    */
  27   public SequenceI[] hiddenSequences;
  28
  29   AlignmentI alignment;
  30
  31   public HiddenSequences(AlignmentI al)
  32   {
  33     alignment = al;
  34   }
  35
  36   public int getSize()
  37   {
  38     if (hiddenSequences == null)
  39     {
  40       return 0;
  41     }
  42     int count = 0;
  43     for (int i = 0; i < hiddenSequences.length; i++)
  44     {
  45       if (hiddenSequences[i] != null)
  46       {
  47         count++;
  48       }
  49     }
  50
  51     return count;
  52   }
  53
  54   public int getWidth()
  55   {
  56     int width = 0;
  57     for (int i = 0; i < hiddenSequences.length; i++)
  58     {
  59       if (hiddenSequences[i] != null
  60               && hiddenSequences[i].getLength() > width)
  61       {
  62         width = hiddenSequences[i].getLength();
  63       }
  64     }
  65
  66     return width;
  67   }
  68
  69   /**
  70    * Call this method if sequences are removed from the main alignment
  71    */
  72   public void adjustHeightSequenceDeleted(int seqIndex)
  73   {
  74     if (hiddenSequences == null)
  75     {
  76       return;
  77     }
  78
  79     int alHeight = alignment.getHeight();
  80
  81     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
  82     int deletionIndex = adjustForHiddenSeqs(seqIndex);
  83
  84     for (int i = 0; i < hiddenSequences.length; i++)
  85     {
  86       if (hiddenSequences[i] == null)
  87       {
  88         continue;
  89       }
  90
  91       if (i > deletionIndex)
  92       {
  93         tmp[i - 1] = hiddenSequences[i];
  94       }
  95       else
  96       {
  97         tmp[i] = hiddenSequences[i];
  98       }
  99     }
 100
 101     hiddenSequences = tmp;
 102
 103   }
 104
 105   /**
 106    * Call this method if sequences are added to or removed from the main
 107    * alignment
 108    */
 109   public void adjustHeightSequenceAdded()
 110   {
 111     if (hiddenSequences == null)
 112     {
 113       return;
 114     }
 115
 116     int alHeight = alignment.getHeight();
 117
 118     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
 119     System.arraycopy(hiddenSequences, 0, tmp, 0, hiddenSequences.length);
 120     hiddenSequences = tmp;
 121   }
 122
 123   public void hideSequence(SequenceI sequence)
 124   {
 125     if (hiddenSequences == null)
 126     {
 127       hiddenSequences = new SequenceI[alignment.getHeight()];
 128     }
 129
 130     int alignmentIndex = alignment.findIndex(sequence);
 131     alignmentIndex = adjustForHiddenSeqs(alignmentIndex);
 132
 133     if (hiddenSequences[alignmentIndex] != null)
 134     {
 135       System.out.println("ERROR!!!!!!!!!!!");
 136     }
 137
 138     hiddenSequences[alignmentIndex] = sequence;
 139
 140     alignment.deleteSequence(sequence);
 141   }
 142
 143   public Vector showAll(Hashtable hiddenReps)
 144   {
 145     Vector revealedSeqs = new Vector();
 146     for (int i = 0; i < hiddenSequences.length; i++)
 147     {
 148       if (hiddenSequences[i] != null)
 149       {
 150         Vector tmp = showSequence(i, hiddenReps);
 151         for (int t = 0; t < tmp.size(); t++)
 152         {
 153           revealedSeqs.addElement(tmp.elementAt(t));
 154         }
 155       }
 156     }
 157     return revealedSeqs;
 158   }
 159
 160   public Vector showSequence(int alignmentIndex, Hashtable hiddenReps)
 161   {
 162     Vector revealedSeqs = new Vector();
 163     SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
 164     if (repSequence != null && hiddenReps != null
 165             && hiddenReps.containsKey(repSequence))
 166     {
 167       hiddenReps.remove(repSequence);
 168       revealedSeqs.addElement(repSequence);
 169     }
 170
 171     int start = adjustForHiddenSeqs(alignmentIndex - 1);
 172     int end = adjustForHiddenSeqs(alignmentIndex);
 173     if (end >= hiddenSequences.length)
 174     {
 175       end = hiddenSequences.length - 1;
 176     }
 177
 178     for (int index = end; index > start; index--)
 179     {
 180       SequenceI seq = hiddenSequences[index];
 181       hiddenSequences[index] = null;
 182
 183       if (seq != null)
 184       {
 185         if (seq.getLength() > 0)
 186         {
 187           revealedSeqs.addElement(seq);
 188           alignment.getSequences().insertElementAt(seq, alignmentIndex);
 189         }
 190         else
 191         {
 192           System.out.println(seq.getName()
 193                   + " has been deleted whilst hidden");
 194         }
 195       }
 196
 197     }
 198
 199     return revealedSeqs;
 200   }
 201
 202   public SequenceI getHiddenSequence(int alignmentIndex)
 203   {
 204     return hiddenSequences[alignmentIndex];
 205   }
 206
 207   public int findIndexWithoutHiddenSeqs(int alignmentIndex)
 208   {
 209     int index = 0;
 210     int hiddenSeqs = 0;
 211     if (hiddenSequences.length <= alignmentIndex)
 212     {
 213       alignmentIndex = hiddenSequences.length - 1;
 214     }
 215
 216     while (index <= alignmentIndex)
 217     {
 218       if (hiddenSequences[index] != null)
 219       {
 220         hiddenSeqs++;
 221       }
 222       index++;
 223     }
 224     ;
 225
 226     return (alignmentIndex - hiddenSeqs);
 227   }
 228
 229   public int adjustForHiddenSeqs(int alignmentIndex)
 230   {
 231     int index = 0;
 232     int hSize = hiddenSequences.length;
 233     while (index <= alignmentIndex && index < hSize)
 234     {
 235       if (hiddenSequences[index] != null)
 236       {
 237         alignmentIndex++;
 238       }
 239       index++;
 240     }
 241     ;
 242
 243     return alignmentIndex;
 244   }
 245
 246   public AlignmentI getFullAlignment()
 247   {
 248     int isize = hiddenSequences.length;
 249     SequenceI[] seq = new Sequence[isize];
 250
 251     int index = 0;
 252     for (int i = 0; i < hiddenSequences.length; i++)
 253     {
 254       if (hiddenSequences[i] != null)
 255       {
 256         seq[i] = hiddenSequences[i];
 257       }
 258       else
 259       {
 260         seq[i] = alignment.getSequenceAt(index);
 261         index++;
 262       }
 263     }
 264
 265     return new Alignment(seq);
 266   }
 267
 268   public boolean isHidden(SequenceI seq)
 269   {
 270     for (int i = 0; i < hiddenSequences.length; i++)
 271     {
 272       if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
 273       {
 274         return true;
 275       }
 276     }
 277
 278     return false;
 279   }
 280 }