src/jalview/datamodel/HiddenSequences.java

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