src/jalview/datamodel/HiddenSequences.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
   3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, 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(
 144           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
 145   {
 146     Vector revealedSeqs = new Vector();
 147     for (int i = 0; i < hiddenSequences.length; i++)
 148     {
 149       if (hiddenSequences[i] != null)
 150       {
 151         Vector tmp = showSequence(i, hiddenRepSequences);
 152         for (int t = 0; t < tmp.size(); t++)
 153         {
 154           revealedSeqs.addElement(tmp.elementAt(t));
 155         }
 156       }
 157     }
 158     return revealedSeqs;
 159   }
 160
 161   public Vector showSequence(int alignmentIndex,
 162           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
 163   {
 164     Vector revealedSeqs = new Vector();
 165     SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
 166     if (repSequence != null && hiddenRepSequences != null
 167             && hiddenRepSequences.containsKey(repSequence))
 168     {
 169       hiddenRepSequences.remove(repSequence);
 170       revealedSeqs.addElement(repSequence);
 171     }
 172
 173     int start = adjustForHiddenSeqs(alignmentIndex - 1);
 174     int end = adjustForHiddenSeqs(alignmentIndex);
 175     if (end >= hiddenSequences.length)
 176     {
 177       end = hiddenSequences.length - 1;
 178     }
 179
 180     List<SequenceI> asequences;
 181     synchronized (asequences = alignment.getSequences())
 182     {
 183       for (int index = end; index > start; index--)
 184       {
 185         SequenceI seq = hiddenSequences[index];
 186         hiddenSequences[index] = null;
 187
 188         if (seq != null)
 189         {
 190           if (seq.getLength() > 0)
 191           {
 192             revealedSeqs.addElement(seq);
 193             asequences.add(alignmentIndex, seq);
 194           }
 195           else
 196           {
 197             System.out.println(seq.getName()
 198                     + " has been deleted whilst hidden");
 199           }
 200         }
 201
 202       }
 203     }
 204
 205     return revealedSeqs;
 206   }
 207
 208   public SequenceI getHiddenSequence(int alignmentIndex)
 209   {
 210     return hiddenSequences[alignmentIndex];
 211   }
 212
 213   public int findIndexWithoutHiddenSeqs(int alignmentIndex)
 214   {
 215     int index = 0;
 216     int hiddenSeqs = 0;
 217     if (hiddenSequences.length <= alignmentIndex)
 218     {
 219       alignmentIndex = hiddenSequences.length - 1;
 220     }
 221
 222     while (index <= alignmentIndex)
 223     {
 224       if (hiddenSequences[index] != null)
 225       {
 226         hiddenSeqs++;
 227       }
 228       index++;
 229     }
 230     ;
 231
 232     return (alignmentIndex - hiddenSeqs);
 233   }
 234
 235   public int adjustForHiddenSeqs(int alignmentIndex)
 236   {
 237     int index = 0;
 238     int hSize = hiddenSequences.length;
 239     while (index <= alignmentIndex && index < hSize)
 240     {
 241       if (hiddenSequences[index] != null)
 242       {
 243         alignmentIndex++;
 244       }
 245       index++;
 246     }
 247     ;
 248
 249     return alignmentIndex;
 250   }
 251
 252   public AlignmentI getFullAlignment()
 253   {
 254     int isize = hiddenSequences.length;
 255     SequenceI[] seq = new Sequence[isize];
 256
 257     int index = 0;
 258     for (int i = 0; i < hiddenSequences.length; i++)
 259     {
 260       if (hiddenSequences[i] != null)
 261       {
 262         seq[i] = hiddenSequences[i];
 263       }
 264       else
 265       {
 266         seq[i] = alignment.getSequenceAt(index);
 267         index++;
 268       }
 269     }
 270
 271     return new Alignment(seq);
 272   }
 273
 274   public boolean isHidden(SequenceI seq)
 275   {
 276     for (int i = 0; i < hiddenSequences.length; i++)
 277     {
 278       if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
 279       {
 280         return true;
 281       }
 282     }
 283
 284     return false;
 285   }
 286 }