src/jalview/analysis/SeqsetUtils.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
   3  * Copyright (C) 2008 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19 package jalview.analysis;
  20
  21 import java.util.*;
  22
  23 import jalview.datamodel.*;
  24
  25 /**
  26  * <p>
  27  * Title:
  28  * </p>
  29  *
  30  * <p>
  31  * Description:
  32  * </p>
  33  *
  34  * <p>
  35  * Copyright: Copyright (c) 2004
  36  * </p>
  37  *
  38  * <p>
  39  * Company: Dundee University
  40  * </p>
  41  *
  42  * @author not attributable
  43  * @version 1.0
  44  */
  45 public class SeqsetUtils
  46 {
  47
  48   /**
  49    * Store essential properties of a sequence in a hashtable for later recovery
  50    * Keys are Name, Start, End, SeqFeatures, PdbId
  51    *
  52    * @param seq
  53    *                SequenceI
  54    * @return Hashtable
  55    */
  56   public static Hashtable SeqCharacterHash(SequenceI seq)
  57   {
  58     Hashtable sqinfo = new Hashtable();
  59     sqinfo.put("Name", seq.getName());
  60     sqinfo.put("Start", new Integer(seq.getStart()));
  61     sqinfo.put("End", new Integer(seq.getEnd()));
  62     if (seq.getDescription() != null)
  63     {
  64       sqinfo.put("Description", seq.getDescription());
  65     }
  66     Vector sfeat = new Vector();
  67     jalview.datamodel.SequenceFeature[] sfarray = seq.getSequenceFeatures();
  68     if (sfarray != null && sfarray.length > 0)
  69     {
  70       for (int i = 0; i < sfarray.length; i++)
  71       {
  72         sfeat.addElement(sfarray[i]);
  73       }
  74     }
  75     sqinfo.put("SeqFeatures", sfeat);
  76     sqinfo.put("PdbId", (seq.getPDBId() != null) ? seq.getPDBId()
  77             : new Vector());
  78     sqinfo.put("datasetSequence", (seq.getDatasetSequence() != null) ? seq
  79             .getDatasetSequence() : 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
 225    *                in the 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, sequences[i]
 292                       .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 }