src/jalview/analysis/SeqsetUtils.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6)
   3  * Copyright (C) 2010 J Procter, AM Waterhouse, 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.analysis;
  19
  20 import java.util.*;
  21
  22 import jalview.datamodel.*;
  23
  24 /**
  25  * <p>
  26  * Title:
  27  * </p>
  28  *
  29  * <p>
  30  * Description:
  31  * </p>
  32  *
  33  * <p>
  34  * Copyright: Copyright (c) 2004
  35  * </p>
  36  *
  37  * <p>
  38  * Company: Dundee University
  39  * </p>
  40  *
  41  * @author not attributable
  42  * @version 1.0
  43  */
  44 public class SeqsetUtils
  45 {
  46
  47   /**
  48    * Store essential properties of a sequence in a hashtable for later recovery
  49    * Keys are Name, Start, End, SeqFeatures, PdbId
  50    *
  51    * @param seq
  52    *          SequenceI
  53    * @return Hashtable
  54    */
  55   public static Hashtable SeqCharacterHash(SequenceI seq)
  56   {
  57     Hashtable sqinfo = new Hashtable();
  58     sqinfo.put("Name", seq.getName());
  59     sqinfo.put("Start", new Integer(seq.getStart()));
  60     sqinfo.put("End", new Integer(seq.getEnd()));
  61     if (seq.getDescription() != null)
  62     {
  63       sqinfo.put("Description", seq.getDescription());
  64     }
  65     Vector sfeat = new Vector();
  66     jalview.datamodel.SequenceFeature[] sfarray = seq.getSequenceFeatures();
  67     if (sfarray != null && sfarray.length > 0)
  68     {
  69       for (int i = 0; i < sfarray.length; i++)
  70       {
  71         sfeat.addElement(sfarray[i]);
  72       }
  73     }
  74     sqinfo.put("SeqFeatures", sfeat);
  75     sqinfo.put("PdbId", (seq.getPDBId() != null) ? seq.getPDBId()
  76             : new Vector());
  77     sqinfo.put("datasetSequence",
  78             (seq.getDatasetSequence() != null) ? seq.getDatasetSequence()
  79                     : new Sequence("THISISAPLACEHOLDER", ""));
  80     return sqinfo;
  81   }
  82
  83   /**
  84    * Recover essential properties of a sequence from a hashtable TODO: replace
  85    * these methods with something more elegant.
  86    *
  87    * @param sq
  88    *          SequenceI
  89    * @param sqinfo
  90    *          Hashtable
  91    * @return boolean true if name was not updated from sqinfo Name entry
  92    */
  93   public static boolean SeqCharacterUnhash(SequenceI sq, Hashtable sqinfo)
  94   {
  95     boolean namePresent = true;
  96     if (sqinfo == null)
  97     {
  98       return false;
  99     }
 100     String oldname = (String) sqinfo.get("Name");
 101     Integer start = (Integer) sqinfo.get("Start");
 102     Integer end = (Integer) sqinfo.get("End");
 103     Vector sfeatures = (Vector) sqinfo.get("SeqFeatures");
 104     Vector pdbid = (Vector) sqinfo.get("PdbId");
 105     String description = (String) sqinfo.get("Description");
 106     Sequence seqds = (Sequence) sqinfo.get("datasetSequence");
 107     if (oldname == null)
 108     {
 109       namePresent = false;
 110     }
 111     else
 112     {
 113       sq.setName(oldname);
 114     }
 115     if (pdbid != null && pdbid.size() > 0)
 116     {
 117       sq.setPDBId(pdbid);
 118     }
 119
 120     if ((start != null) && (end != null))
 121     {
 122       sq.setStart(start.intValue());
 123       sq.setEnd(end.intValue());
 124     }
 125
 126     if ((sfeatures != null) && (sfeatures.size() > 0))
 127     {
 128       SequenceFeature[] sfarray = new SequenceFeature[sfeatures.size()];
 129       for (int is = 0, isize = sfeatures.size(); is < isize; is++)
 130       {
 131         sfarray[is] = (SequenceFeature) sfeatures.elementAt(is);
 132       }
 133       sq.setSequenceFeatures(sfarray);
 134     }
 135     if (description != null)
 136     {
 137       sq.setDescription(description);
 138     }
 139     if ((seqds != null)
 140             && !(seqds.getName().equals("THISISAPLACEHOLDER") && seqds
 141                     .getLength() == 0))
 142     {
 143       sq.setDatasetSequence(seqds);
 144     }
 145
 146     return namePresent;
 147   }
 148
 149   /**
 150    * Form of the unique name used in uniquify for the i'th sequence in an
 151    * ordered vector of sequences.
 152    *
 153    * @param i
 154    *          int
 155    * @return String
 156    */
 157   public static String unique_name(int i)
 158   {
 159     return new String("Sequence" + i);
 160   }
 161
 162   /**
 163    * Generates a hash of SeqCharacterHash properties for each sequence in a
 164    * sequence set, and optionally renames the sequences to an unambiguous 'safe'
 165    * name.
 166    *
 167    * @param sequences
 168    *          SequenceI[]
 169    * @param write_names
 170    *          boolean set this to rename each of the sequences to its
 171    *          unique_name(index) name
 172    * @return Hashtable to be passed to
 173    * @see deuniquify to recover original names (and properties) for renamed
 174    *      sequences
 175    */
 176   public static Hashtable uniquify(SequenceI[] sequences,
 177           boolean write_names)
 178   {
 179     // Generate a safely named sequence set and a hash to recover the sequence
 180     // names
 181     Hashtable map = new Hashtable();
 182     // String[] un_names = new String[sequences.length];
 183
 184     for (int i = 0; i < sequences.length; i++)
 185     {
 186       String safename = unique_name(i);
 187       map.put(safename, SeqCharacterHash(sequences[i]));
 188
 189       if (write_names)
 190       {
 191         sequences[i].setName(safename);
 192       }
 193     }
 194
 195     return map;
 196   }
 197
 198   /**
 199    * recover unsafe sequence names and original properties for a sequence set
 200    * using a map generated by
 201    *
 202    * @see uniquify(sequences,true)
 203    * @param map
 204    *          Hashtable
 205    * @param sequences
 206    *          SequenceI[]
 207    * @return boolean
 208    */
 209   public static boolean deuniquify(Hashtable map, SequenceI[] sequences)
 210   {
 211     return deuniquify(map, sequences, true);
 212   }
 213
 214   /**
 215    * recover unsafe sequence names and original properties for a sequence set
 216    * using a map generated by
 217    *
 218    * @see uniquify(sequences,true)
 219    * @param map
 220    *          Hashtable
 221    * @param sequences
 222    *          SequenceI[]
 223    * @param quiet
 224    *          when false, don't complain about sequences without any data in the
 225    *          map.
 226    * @return boolean
 227    */
 228   public static boolean deuniquify(Hashtable map, SequenceI[] sequences,
 229           boolean quiet)
 230   {
 231     jalview.analysis.SequenceIdMatcher matcher = new SequenceIdMatcher(
 232             sequences);
 233     SequenceI msq = null;
 234     Enumeration keys = map.keys();
 235     Vector unmatched = new Vector();
 236     for (int i = 0, j = sequences.length; i < j; i++)
 237     {
 238       unmatched.addElement(sequences[i]);
 239     }
 240     while (keys.hasMoreElements())
 241     {
 242       Object key = keys.nextElement();
 243       if (key instanceof String)
 244       {
 245         if ((msq = matcher.findIdMatch((String) key)) != null)
 246         {
 247           Hashtable sqinfo = (Hashtable) map.get(key);
 248           unmatched.removeElement(msq);
 249           SeqCharacterUnhash(msq, sqinfo);
 250         }
 251         else
 252         {
 253           if (!quiet)
 254           {
 255             System.err.println("Can't find '" + ((String) key)
 256                     + "' in uniquified alignment");
 257           }
 258         }
 259       }
 260     }
 261     if (unmatched.size() > 0 && !quiet)
 262     {
 263       System.err.println("Did not find matches for :");
 264       for (Enumeration i = unmatched.elements(); i.hasMoreElements(); System.out
 265               .println(((SequenceI) i.nextElement()).getName()))
 266       {
 267         ;
 268       }
 269       return false;
 270     }
 271
 272     return true;
 273   }
 274
 275   /**
 276    * returns a subset of the sequenceI seuqences, including only those that
 277    * contain at least one residue.
 278    *
 279    * @param sequences
 280    *          SequenceI[]
 281    * @return SequenceI[]
 282    */
 283   public static SequenceI[] getNonEmptySequenceSet(SequenceI[] sequences)
 284   {
 285     // Identify first row of alignment with residues for prediction
 286     boolean ungapped[] = new boolean[sequences.length];
 287     int msflen = 0;
 288     for (int i = 0, j = sequences.length; i < j; i++)
 289     {
 290       String tempseq = jalview.analysis.AlignSeq.extractGaps(
 291               jalview.util.Comparison.GapChars,
 292               sequences[i].getSequenceAsString());
 293
 294       if (tempseq.length() == 0)
 295       {
 296         ungapped[i] = false;
 297       }
 298       else
 299       {
 300         ungapped[i] = true;
 301         msflen++;
 302       }
 303     }
 304     if (msflen == 0)
 305     {
 306       return null; // no minimal set
 307     }
 308     // compose minimal set
 309     SequenceI[] mset = new SequenceI[msflen];
 310     for (int i = 0, j = sequences.length, k = 0; i < j; i++)
 311     {
 312       if (ungapped[i])
 313       {
 314         mset[k++] = sequences[i];
 315       }
 316     }
 317     ungapped = null;
 318     return mset;
 319   }
 320 }