JAL-1632 add score model params to PCAModel and PCA constructors
[jalview.git] / src / jalview / datamodel / SearchResults.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ 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.ArrayList;
24 import java.util.BitSet;
25 import java.util.List;
26
27 /**
28  * Holds a list of search result matches, where each match is a contiguous
29  * stretch of a single sequence.
30  * 
31  * @author gmcarstairs amwaterhouse
32  *
33  */
34 public class SearchResults implements SearchResultsI
35 {
36
37   private List<SearchResultMatchI> matches = new ArrayList<SearchResultMatchI>();
38
39   /**
40    * One match consists of a sequence reference, start and end positions.
41    * Discontiguous ranges in a sequence require two or more Match objects.
42    */
43   public class Match implements SearchResultMatchI
44   {
45     SequenceI sequence;
46
47     /**
48      * Start position of match in sequence (base 1)
49      */
50     int start;
51
52     /**
53      * End position (inclusive) (base 1)
54      */
55     int end;
56
57     /**
58      * create a Match on a range of sequence. Match always holds region in
59      * forwards order, even if given in reverse order (such as from a mapping to
60      * a reverse strand); this avoids trouble for routines that highlight search
61      * results etc
62      * 
63      * @param seq
64      *          a sequence
65      * @param start
66      *          start position of matched range (base 1)
67      * @param end
68      *          end of matched range (inclusive, base 1)
69      */
70     public Match(SequenceI seq, int start, int end)
71     {
72       sequence = seq;
73
74       /*
75        * always hold in forwards order, even if given in reverse order
76        * (such as from a mapping to a reverse strand); this avoids
77        * trouble for routines that highlight search results etc
78        */
79       if (start <= end)
80       {
81         this.start = start;
82         this.end = end;
83       }
84       else
85       {
86         // TODO: JBP could mark match as being specified in reverse direction
87         // for use
88         // by caller ? e.g. visualizing reverse strand highlight
89         this.start = end;
90         this.end = start;
91       }
92     }
93
94     /* (non-Javadoc)
95      * @see jalview.datamodel.SearchResultMatchI#getSequence()
96      */
97     @Override
98     public SequenceI getSequence()
99     {
100       return sequence;
101     }
102
103     /* (non-Javadoc)
104      * @see jalview.datamodel.SearchResultMatchI#getStart()
105      */
106     @Override
107     public int getStart()
108     {
109       return start;
110     }
111
112     /* (non-Javadoc)
113      * @see jalview.datamodel.SearchResultMatchI#getEnd()
114      */
115     @Override
116     public int getEnd()
117     {
118       return end;
119     }
120
121     /**
122      * Returns a representation as "seqid/start-end"
123      */
124     @Override
125     public String toString()
126     {
127       StringBuilder sb = new StringBuilder();
128       if (sequence != null)
129       {
130         sb.append(sequence.getName()).append("/");
131       }
132       sb.append(start).append("-").append(end);
133       return sb.toString();
134     }
135
136     public void setSequence(SequenceI seq)
137     {
138       this.sequence = seq;
139     }
140
141     /**
142      * Hashcode is the hashcode of the matched sequence plus a hash of start and
143      * end positions. Match objects that pass the test for equals are guaranteed
144      * to have the same hashcode.
145      */
146     @Override
147     public int hashCode()
148     {
149       int hash = sequence == null ? 0 : sequence.hashCode();
150       hash += 31 * start;
151       hash += 67 * end;
152       return hash;
153     }
154
155     /**
156      * Two Match objects are equal if they are for the same sequence, start and
157      * end positions
158      */
159     @Override
160     public boolean equals(Object obj)
161     {
162       if (obj == null || !(obj instanceof SearchResultMatchI))
163       {
164         return false;
165       }
166       SearchResultMatchI m = (SearchResultMatchI) obj;
167       return (sequence == m.getSequence() && start == m.getStart() && end == m
168               .getEnd());
169     }
170   }
171
172   /* (non-Javadoc)
173    * @see jalview.datamodel.SearchResultsI#addResult(jalview.datamodel.SequenceI, int, int)
174    */
175   @Override
176   public SearchResultMatchI addResult(SequenceI seq, int start, int end)
177   {
178     Match m = new Match(seq, start, end);
179     matches.add(m);
180     return m;
181   }
182
183   /* (non-Javadoc)
184    * @see jalview.datamodel.SearchResultsI#involvesSequence(jalview.datamodel.SequenceI)
185    */
186   @Override
187   public boolean involvesSequence(SequenceI sequence)
188   {
189     SequenceI ds = sequence.getDatasetSequence();
190     for (SearchResultMatchI _m : matches)
191     {
192       SequenceI matched = _m.getSequence();
193       if (matched != null && (matched == sequence || matched == ds))
194       {
195         return true;
196       }
197     }
198     return false;
199   }
200
201   /* (non-Javadoc)
202    * @see jalview.datamodel.SearchResultsI#getResults(jalview.datamodel.SequenceI, int, int)
203    */
204   @Override
205   public int[] getResults(SequenceI sequence, int start, int end)
206   {
207     if (matches.isEmpty())
208     {
209       return null;
210     }
211
212     int[] result = null;
213     int[] tmp = null;
214     int resultLength, matchStart = 0, matchEnd = 0;
215     boolean mfound;
216     Match m;
217     for (SearchResultMatchI _m : matches)
218     {
219       m = (Match) _m;
220
221       mfound = false;
222       if (m.sequence == sequence)
223       {
224         mfound = true;
225         // locate aligned position
226         matchStart = sequence.findIndex(m.start) - 1;
227         matchEnd = sequence.findIndex(m.end) - 1;
228       }
229       else if (m.sequence == sequence.getDatasetSequence())
230       {
231         mfound = true;
232         // locate region in local context
233         matchStart = sequence.findIndex(m.start) - 1;
234         matchEnd = sequence.findIndex(m.end) - 1;
235       }
236       if (mfound)
237       {
238         if (matchStart <= end && matchEnd >= start)
239         {
240           if (matchStart < start)
241           {
242             matchStart = start;
243           }
244
245           if (matchEnd > end)
246           {
247             matchEnd = end;
248           }
249
250           if (result == null)
251           {
252             result = new int[] { matchStart, matchEnd };
253           }
254           else
255           {
256             resultLength = result.length;
257             tmp = new int[resultLength + 2];
258             System.arraycopy(result, 0, tmp, 0, resultLength);
259             result = tmp;
260             result[resultLength] = matchStart;
261             result[resultLength + 1] = matchEnd;
262           }
263         }
264         else
265         {
266           // debug
267           // System.err.println("Outwith bounds!" + matchStart+">"+end +"  or "
268           // + matchEnd+"<"+start);
269         }
270       }
271     }
272     return result;
273   }
274
275   @Override
276   public int markColumns(SequenceCollectionI sqcol, BitSet bs)
277   {
278     int count = 0;
279     BitSet mask = new BitSet();
280     for (SequenceI s : sqcol.getSequences())
281     {
282       int[] cols = getResults(s, sqcol.getStartRes(), sqcol.getEndRes());
283       if (cols != null)
284       {
285         for (int pair = 0; pair < cols.length; pair += 2)
286         {
287           mask.set(cols[pair], cols[pair + 1] + 1);
288         }
289       }
290     }
291     // compute columns that were newly selected
292     BitSet original = (BitSet) bs.clone();
293     original.and(mask);
294     count = mask.cardinality() - original.cardinality();
295     // and mark ranges not already marked
296     bs.or(mask);
297     return count;
298   }
299
300   /* (non-Javadoc)
301    * @see jalview.datamodel.SearchResultsI#getSize()
302    */
303   @Override
304   public int getSize()
305   {
306     return matches.size();
307   }
308
309   /* (non-Javadoc)
310    * @see jalview.datamodel.SearchResultsI#isEmpty()
311    */
312   @Override
313   public boolean isEmpty()
314   {
315     return matches.isEmpty();
316   }
317
318   /* (non-Javadoc)
319    * @see jalview.datamodel.SearchResultsI#getResults()
320    */
321   @Override
322   public List<SearchResultMatchI> getResults()
323   {
324     return matches;
325   }
326
327   /**
328    * Return the results as a list of matches [seq1/from-to, seq2/from-to, ...]
329    * 
330    * @return
331    */
332   @Override
333   public String toString()
334   {
335     return matches == null ? "" : matches.toString();
336   }
337
338   /**
339    * Hashcode is derived from the list of matches. This ensures that when two
340    * SearchResults objects satisfy the test for equals(), then they have the
341    * same hashcode.
342    * 
343    * @see Match#hashCode()
344    * @see java.util.AbstractList#hashCode()
345    */
346   @Override
347   public int hashCode()
348   {
349     return matches.hashCode();
350   }
351
352   /**
353    * Two SearchResults are considered equal if they contain the same matches in
354    * the same order.
355    */
356   @Override
357   public boolean equals(Object obj)
358   {
359     if (obj == null || !(obj instanceof SearchResultsI))
360     {
361       return false;
362     }
363     SearchResultsI sr = (SearchResultsI) obj;
364     return matches.equals(sr.getResults());
365   }
366 }