src/jalview/datamodel/HiddenSequences.java

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