Use system path separator char
[jalview.git] / src / jalview / analysis / SeqsetUtils.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer
3  * Copyright (C) 2006 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>Title: </p>
27  *
28  * <p>Description: </p>
29  *
30  * <p>Copyright: Copyright (c) 2004</p>
31  *
32  * <p>Company: Dundee University</p>
33  *
34  * @author not attributable
35  * @version 1.0
36  */
37 public class SeqsetUtils
38 {
39
40   /**
41    * Store essential properties of a sequence in a hashtable for later recovery
42    *  Keys are Name, Start, End, SeqFeatures, PdbId
43    * @param seq SequenceI
44    * @return Hashtable
45    */
46   public static Hashtable SeqCharacterHash(SequenceI seq)
47   {
48     Hashtable sqinfo = new Hashtable();
49     sqinfo.put("Name", seq.getName());
50     sqinfo.put("Start", new Integer(seq.getStart()));
51     sqinfo.put("End", new Integer(seq.getEnd()));
52     if (seq.getDescription()!=null)
53       sqinfo.put("Description", seq.getDescription());
54     Vector sfeat = new Vector();
55     jalview.datamodel.SequenceFeature[] sfarray=seq.getSequenceFeatures();
56     if (sfarray!=null && sfarray.length>0) {
57       for (int i=0;i<sfarray.length;i++)
58         sfeat.add(sfarray[i]);
59     }
60     sqinfo.put("SeqFeatures", sfeat);
61     sqinfo.put("PdbId",
62                (seq.getPDBId() != null) ? seq.getPDBId() : new Vector());
63     sqinfo.put("datasetSequence", (seq.getDatasetSequence() !=null) ? seq.getDatasetSequence() : new Sequence("THISISAPLACEHOLDER",""));
64     return sqinfo;
65   }
66
67   /**
68    * Recover essential properties of a sequence from a hashtable
69    * TODO: replace these methods with something more elegant.
70    * @param sq SequenceI
71    * @param sqinfo Hashtable
72    * @return boolean true if name was not updated from sqinfo Name entry
73    */
74   public static boolean SeqCharacterUnhash(SequenceI sq, Hashtable sqinfo)
75   {
76     boolean namePresent = true;
77     if (sqinfo==null)
78       return false;
79     String oldname = (String) sqinfo.get("Name");
80     Integer start = (Integer) sqinfo.get("Start");
81     Integer end = (Integer) sqinfo.get("End");
82     Vector sfeatures = (Vector) sqinfo.get(
83         "SeqFeatures");
84     Vector pdbid = (Vector) sqinfo.get("PdbId");
85     String description=(String) sqinfo.get("Description");
86     Sequence seqds = (Sequence) sqinfo.get("datasetSequence");
87     if (oldname == null)
88     {
89       namePresent = false;
90     }
91     else
92     {
93       sq.setName(oldname);
94     }
95     if (pdbid!=null && pdbid.size()>0)
96     {
97       sq.setPDBId(pdbid);
98     }
99
100     if ( (start != null) && (end != null))
101     {
102       sq.setStart(start.intValue());
103       sq.setEnd(end.intValue());
104     }
105
106     if ((sfeatures != null) && (sfeatures.size()>0))
107     {
108       SequenceFeature[] sfarray = (SequenceFeature[]) sfeatures.toArray();
109       sq.setSequenceFeatures(sfarray);
110     }
111     if (description!=null)
112       sq.setDescription(description);
113     if ((seqds!=null) && !(seqds.getName().equals("THISISAPLACEHOLDER") && seqds.getLength()==0)) {
114       sq.setDatasetSequence(seqds);
115     }
116
117     return namePresent;
118   }
119
120   /**
121    * Form of the unique name used in uniquify for the i'th sequence in an ordered vector of sequences.
122    * @param i int
123    * @return String
124    */
125   public static String unique_name(int i)
126   {
127     return new String("Sequence" + i);
128   }
129
130   /**
131    * Generates a hash of SeqCharacterHash properties for each sequence
132    * in a sequence set, and optionally renames the sequences to an
133    * unambiguous 'safe' name.
134    * @param sequences SequenceI[]
135    * @param write_names boolean set this to rename each of the sequences to its unique_name(index) name
136    * @return Hashtable to be passed to @see deuniquify to recover original names (and properties) for renamed sequences
137    */
138   public static Hashtable uniquify(SequenceI[] sequences, boolean write_names)
139   {
140     // Generate a safely named sequence set and a hash to recover the sequence names
141     Hashtable map = new Hashtable();
142     //String[] un_names = new String[sequences.length];
143
144     for (int i = 0; i < sequences.length; i++)
145     {
146       String safename = unique_name(i);
147       map.put(safename, SeqCharacterHash(sequences[i]));
148
149       if (write_names)
150       {
151         sequences[i].setName(safename);
152       }
153     }
154
155
156     return map;
157   }
158   /**
159    * recover unsafe sequence names and original properties for a sequence
160    * set using a map generated by @see uniquify(sequences,true)
161    * @param map Hashtable
162    * @param sequences SequenceI[]
163    * @return boolean
164    */
165   public static boolean deuniquify(Hashtable map, SequenceI[] sequences)
166   {
167     jalview.analysis.SequenceIdMatcher matcher = new SequenceIdMatcher(sequences);
168     SequenceI msq = null;
169     Enumeration keys = map.keys();
170     Vector unmatched = new Vector();
171     for (int i=0, j=sequences.length; i<j; i++)
172       unmatched.add(sequences[i]);
173     while (keys.hasMoreElements()) {
174       Object key = keys.nextElement();
175       if (key instanceof String) {
176         if ((msq = matcher.findIdMatch((String) key))!=null) {
177           Hashtable sqinfo = (Hashtable) map.get(key);
178           unmatched.remove(msq);
179           SeqCharacterUnhash(msq, sqinfo);
180         }
181         else
182         {
183           System.err.println("Can't find '"+((String) key)+"' in uniquified alignment");
184         }
185       }
186     }
187     if (unmatched.size()>0) {
188       System.err.println("Did not find matches for :");
189       for (Enumeration i = unmatched.elements(); i.hasMoreElements(); System.out.println(((SequenceI) i.nextElement()).getName()))
190            ;
191       return false;
192     }
193
194     return true;
195   }
196   /**
197    * returns a subset of the sequenceI seuqences,
198    * including only those that contain at least one residue.
199    * @param sequences SequenceI[]
200    * @return SequenceI[]
201    */
202   public static SequenceI[] getNonEmptySequenceSet(SequenceI[] sequences) {
203       // Identify first row of alignment with residues for prediction
204       boolean ungapped[] = new boolean[sequences.length];
205       int msflen=0;
206       for (int i=0,j=sequences.length; i<j;i++) {
207         String tempseq = jalview.analysis.AlignSeq.extractGaps(jalview.util.Comparison.GapChars, sequences[i].getSequence());
208         if (tempseq.length()==0)
209           ungapped[i]=false;
210         else {
211           ungapped[i]=true;
212           msflen++;
213         }
214       }
215       if (msflen==0)
216         return null; // no minimal set
217       // compose minimal set
218       SequenceI[] mset = new SequenceI[msflen];
219       for (int i=0,j=sequences.length,k=0; i<j;i++) {
220         if (ungapped[i])
221           mset[k++] = sequences[i];
222       }
223       ungapped = null;
224       return mset;
225   }
226 }