src/jalview/datamodel/HiddenSequences.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.datamodel;
  22
  23 import java.util.ArrayList;
  24 import java.util.List;
  25 import java.util.Map;
  26
  27 public class HiddenSequences
  28 {
  29   /**
  30    * holds a list of hidden sequences associated with an alignment.
  31    */
  32   public SequenceI[] hiddenSequences;
  33
  34   AlignmentI alignment;
  35
  36   public HiddenSequences(AlignmentI al)
  37   {
  38     alignment = al;
  39   }
  40
  41   public int getSize()
  42   {
  43     if (hiddenSequences == null)
  44     {
  45       return 0;
  46     }
  47     int count = 0;
  48     for (int i = 0; i < hiddenSequences.length; i++)
  49     {
  50       if (hiddenSequences[i] != null)
  51       {
  52         count++;
  53       }
  54     }
  55
  56     return count;
  57   }
  58
  59   public int getWidth()
  60   {
  61     int width = 0;
  62     for (int i = 0; i < hiddenSequences.length; i++)
  63     {
  64       if (hiddenSequences[i] != null
  65               && hiddenSequences[i].getLength() > width)
  66       {
  67         width = hiddenSequences[i].getLength();
  68       }
  69     }
  70
  71     return width;
  72   }
  73
  74   /**
  75    * Call this method if sequences are removed from the main alignment
  76    */
  77   public void adjustHeightSequenceDeleted(int seqIndex)
  78   {
  79     if (hiddenSequences == null)
  80     {
  81       return;
  82     }
  83
  84     int alHeight = alignment.getHeight();
  85
  86     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
  87     int deletionIndex = adjustForHiddenSeqs(seqIndex);
  88
  89     for (int i = 0; i < hiddenSequences.length; i++)
  90     {
  91       if (hiddenSequences[i] == null)
  92       {
  93         continue;
  94       }
  95
  96       if (i > deletionIndex)
  97       {
  98         tmp[i - 1] = hiddenSequences[i];
  99       }
 100       else
 101       {
 102         tmp[i] = hiddenSequences[i];
 103       }
 104     }
 105
 106     hiddenSequences = tmp;
 107
 108   }
 109
 110   /**
 111    * Call this method if sequences are added to or removed from the main
 112    * alignment
 113    */
 114   public void adjustHeightSequenceAdded()
 115   {
 116     if (hiddenSequences == null)
 117     {
 118       return;
 119     }
 120
 121     int alHeight = alignment.getHeight();
 122
 123     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
 124     System.arraycopy(hiddenSequences, 0, tmp, 0, hiddenSequences.length);
 125     hiddenSequences = tmp;
 126   }
 127
 128   public void hideSequence(SequenceI sequence)
 129   {
 130     if (hiddenSequences == null)
 131     {
 132       hiddenSequences = new SequenceI[alignment.getHeight()];
 133     }
 134
 135     int alignmentIndex = alignment.findIndex(sequence);
 136     alignmentIndex = adjustForHiddenSeqs(alignmentIndex);
 137
 138     if (hiddenSequences[alignmentIndex] != null)
 139     {
 140       System.out.println("ERROR!!!!!!!!!!!");
 141     }
 142
 143     hiddenSequences[alignmentIndex] = sequence;
 144
 145     alignment.deleteSequence(sequence);
 146   }
 147
 148   public List<SequenceI> showAll(
 149           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
 150   {
 151     List<SequenceI> revealedSeqs = new ArrayList<SequenceI>();
 152     for (int i = 0; i < hiddenSequences.length; i++)
 153     {
 154       if (hiddenSequences[i] != null)
 155       {
 156         List<SequenceI> tmp = showSequence(i, hiddenRepSequences);
 157         for (SequenceI seq : tmp)
 158         {
 159           revealedSeqs.add(seq);
 160         }
 161       }
 162     }
 163     return revealedSeqs;
 164   }
 165
 166   public List<SequenceI> showSequence(int alignmentIndex,
 167           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
 168   {
 169     List<SequenceI> revealedSeqs = new ArrayList<SequenceI>();
 170     SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
 171     if (repSequence != null && hiddenRepSequences != null
 172             && hiddenRepSequences.containsKey(repSequence))
 173     {
 174       hiddenRepSequences.remove(repSequence);
 175       revealedSeqs.add(repSequence);
 176     }
 177
 178     int start = adjustForHiddenSeqs(alignmentIndex - 1);
 179     int end = adjustForHiddenSeqs(alignmentIndex);
 180     if (end >= hiddenSequences.length)
 181     {
 182       end = hiddenSequences.length - 1;
 183     }
 184
 185     List<SequenceI> asequences;
 186     synchronized (asequences = alignment.getSequences())
 187     {
 188       for (int index = end; index > start; index--)
 189       {
 190         SequenceI seq = hiddenSequences[index];
 191         hiddenSequences[index] = null;
 192
 193         if (seq != null)
 194         {
 195           if (seq.getLength() > 0)
 196           {
 197             revealedSeqs.add(seq);
 198             asequences.add(alignmentIndex, seq);
 199           }
 200           else
 201           {
 202             System.out.println(seq.getName()
 203                     + " has been deleted whilst hidden");
 204           }
 205         }
 206
 207       }
 208     }
 209
 210     return revealedSeqs;
 211   }
 212
 213   public SequenceI getHiddenSequence(int alignmentIndex)
 214   {
 215     return hiddenSequences[alignmentIndex];
 216   }
 217
 218   public int findIndexWithoutHiddenSeqs(int alignmentIndex)
 219   {
 220     int index = 0;
 221     int hiddenSeqs = 0;
 222     if (hiddenSequences.length <= alignmentIndex)
 223     {
 224       alignmentIndex = hiddenSequences.length - 1;
 225     }
 226
 227     while (index <= alignmentIndex)
 228     {
 229       if (hiddenSequences[index] != null)
 230       {
 231         hiddenSeqs++;
 232       }
 233       index++;
 234     }
 235     ;
 236
 237     return (alignmentIndex - hiddenSeqs);
 238   }
 239
 240   public int adjustForHiddenSeqs(int alignmentIndex)
 241   {
 242     int index = 0;
 243     int hSize = hiddenSequences.length;
 244     while (index <= alignmentIndex && index < hSize)
 245     {
 246       if (hiddenSequences[index] != null)
 247       {
 248         alignmentIndex++;
 249       }
 250       index++;
 251     }
 252     ;
 253
 254     return alignmentIndex;
 255   }
 256
 257   public AlignmentI getFullAlignment()
 258   {
 259     int isize = hiddenSequences.length;
 260     SequenceI[] seq = new Sequence[isize];
 261
 262     int index = 0;
 263     for (int i = 0; i < hiddenSequences.length; i++)
 264     {
 265       if (hiddenSequences[i] != null)
 266       {
 267         seq[i] = hiddenSequences[i];
 268       }
 269       else
 270       {
 271         seq[i] = alignment.getSequenceAt(index);
 272         index++;
 273       }
 274     }
 275     Alignment fAlignmt = new Alignment(seq);
 276     fAlignmt.annotations = alignment.getAlignmentAnnotation();
 277     fAlignmt.alignmentProperties = alignment.getProperties();
 278     fAlignmt.groups = alignment.getGroups();
 279     fAlignmt.hasRNAStructure = alignment.hasRNAStructure();
 280
 281     return fAlignmt;
 282   }
 283
 284   public boolean isHidden(SequenceI seq)
 285   {
 286     if (hiddenSequences != null)
 287     {
 288       for (int i = 0; i < hiddenSequences.length; i++)
 289       {
 290         if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
 291         {
 292           return true;
 293         }
 294       }
 295     }
 296
 297     return false;
 298   }
 299 }