JAL-2094 first pass with jalview.api.ColorI interface
[jalview.git] / src / jalview / datamodel / CigarArray.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.List;
24
25 public class CigarArray extends CigarBase
26 {
27   /**
28    * Do CIGAR operations on a set of sequences from many other cigars BAD THINGS
29    * WILL HAPPEN IF A CIGARARRAY IS PASSED TO A CIGARARRAY or a CIGARCIGAR is
30    * given a CIGARARRAY to insert gaps into.
31    */
32   /**
33    * array of subject cigars
34    */
35   public CigarSimple refCigars[] = null;
36
37   private boolean seqcigararray = false;
38
39   private CigarArray()
40   {
41     super();
42   }
43
44   /**
45    * isSeqCigarArray()
46    * 
47    * @return boolean true if all refCigars resolve to a SeqCigar or a CigarCigar
48    */
49   public boolean isSeqCigarArray()
50   {
51     return seqcigararray;
52   }
53
54   /**
55    * Apply CIGAR operations to several cigars in parallel will throw an error if
56    * any of cigar are actually CigarArrays.
57    * 
58    * @param cigar
59    *          Cigar[]
60    */
61   public CigarArray(CigarSimple[] cigars)
62   {
63     super();
64     seqcigararray = true;
65     if (cigars != null && cigars.length > 0)
66     {
67       refCigars = new CigarSimple[cigars.length];
68       for (int c = 0; c < cigars.length; c++)
69       {
70         refCigars[c] = cigars[c];
71         if (!((cigars[c] instanceof SeqCigar) || cigars[c] instanceof CigarCigar))
72         {
73           seqcigararray = false;
74         }
75       }
76     }
77   }
78
79   /**
80    * construct a cigar array from the current alignment, or just the subset of
81    * the current alignment specified by selectionGroup. Any columns marked as
82    * hidden in columnSelection will be marked as deleted in the array.
83    * 
84    * @param alignment
85    * @param columnSelection
86    * @param selectionGroup
87    */
88   public CigarArray(AlignmentI alignment, ColumnSelection columnSelection,
89           SequenceGroup selectionGroup)
90   {
91     this(constructSeqCigarArray(alignment, selectionGroup));
92     constructFromAlignment(alignment,
93             columnSelection != null ? columnSelection.getHiddenColumns()
94                     : null, selectionGroup);
95   }
96
97   private static int[] _calcStartEndBounds(AlignmentI alignment,
98           SequenceGroup selectionGroup)
99   {
100     int[] startend = new int[] { 0, 0, 0 };
101     if (selectionGroup != null)
102     {
103       startend[0] = selectionGroup.getSize();
104       startend[1] = selectionGroup.getStartRes();
105       startend[2] = selectionGroup.getEndRes(); // inclusive for start and end
106                                                 // in
107       // SeqCigar constructor
108     }
109     else
110     {
111       startend[0] = alignment.getHeight();
112       startend[2] = alignment.getWidth() - 1;
113     }
114     return startend;
115   }
116
117   public static SeqCigar[] constructSeqCigarArray(AlignmentI alignment,
118           SequenceGroup selectionGroup)
119   {
120     SequenceI[] seqs = null;
121     int i, iSize;
122     int _startend[] = _calcStartEndBounds(alignment, selectionGroup);
123     int start = _startend[1], end = _startend[2];
124     if (selectionGroup != null)
125     {
126       iSize = selectionGroup.getSize();
127       seqs = selectionGroup.getSequencesInOrder(alignment);
128       start = selectionGroup.getStartRes();
129       end = selectionGroup.getEndRes(); // inclusive for start and end in
130       // SeqCigar constructor
131     }
132     else
133     {
134       iSize = alignment.getHeight();
135       seqs = alignment.getSequencesArray();
136       end = alignment.getWidth() - 1;
137     }
138     SeqCigar[] selseqs = new SeqCigar[iSize];
139     for (i = 0; i < iSize; i++)
140     {
141       selseqs[i] = new SeqCigar(seqs[i], start, end);
142     }
143     return selseqs;
144   }
145
146   /**
147    * internal constructor function - called by CigarArray(AlignmentI, ...);
148    * 
149    * @param alignment
150    * @param list
151    *          - vector of visible regions as returned from
152    *          columnSelection.getHiddenColumns()
153    * @param selectionGroup
154    */
155   private void constructFromAlignment(AlignmentI alignment,
156           List<int[]> list, SequenceGroup selectionGroup)
157   {
158     int[] _startend = _calcStartEndBounds(alignment, selectionGroup);
159     int start = _startend[1], end = _startend[2];
160     // now construct the CigarArray operations
161     if (list != null)
162     {
163       int[] region;
164       int hideStart, hideEnd;
165       int last = start;
166       for (int j = 0; last < end & j < list.size(); j++)
167       {
168         region = list.get(j);
169         hideStart = region[0];
170         hideEnd = region[1];
171         // edit hidden regions to selection range
172         if (hideStart < last)
173         {
174           if (hideEnd > last)
175           {
176             hideStart = last;
177           }
178           else
179           {
180             continue;
181           }
182         }
183
184         if (hideStart > end)
185         {
186           break;
187         }
188
189         if (hideEnd > end)
190         {
191           hideEnd = end;
192         }
193
194         if (hideStart > hideEnd)
195         {
196           break;
197         }
198         /**
199          * form operations...
200          */
201         if (last < hideStart)
202         {
203           addOperation(CigarArray.M, hideStart - last);
204         }
205         addOperation(CigarArray.D, 1 + hideEnd - hideStart);
206         last = hideEnd + 1;
207       }
208       // Final match if necessary.
209       if (last < end)
210       {
211         addOperation(CigarArray.M, end - last + 1);
212       }
213     }
214     else
215     {
216       addOperation(CigarArray.M, end - start + 1);
217     }
218   }
219
220   /**
221    * @see Cigar.getSequenceAndDeletions
222    * @param GapChar
223    *          char
224    * @return Object[][]
225    */
226   protected Object[][] getArrayofSequenceAndDeletions(char GapChar)
227   {
228     if (refCigars == null || refCigars.length == 0 || length == 0)
229     {
230       return null;
231     }
232     Object[][] sqanddels = new Object[refCigars.length][];
233     for (int c = 0; c < refCigars.length; c++)
234     {
235       String refString = refCigars[c].getSequenceString(GapChar);
236       if (refString != null)
237       {
238         sqanddels[c] = getSequenceAndDeletions(refString, GapChar);
239       }
240       else
241       {
242         sqanddels[c] = null;
243       }
244     }
245     return sqanddels;
246   }
247
248   /**
249    * NOTE: this is an improper sequence string function
250    * 
251    * @return String formed by newline concatenated results of applying CIGAR
252    *         operations to each reference object in turn.
253    * @param GapChar
254    *          char
255    * @return '\n' separated strings (empty results included as \n\n)
256    */
257   public String getSequenceString(char GapChar)
258   {
259     if (length == 0 || refCigars == null)
260     {
261       return "";
262     }
263     StringBuffer seqStrings = new StringBuffer();
264     Object[][] sqanddels = getArrayofSequenceAndDeletions(GapChar);
265     for (int c = 0; c < refCigars.length; c++)
266     {
267       if (sqanddels[c] != null)
268       {
269         seqStrings.append((String) sqanddels[c][0]);
270         sqanddels[c][0] = null;
271       }
272       seqStrings.append('\n');
273     }
274     return seqStrings.toString();
275   }
276
277   /**
278    * return string results of applying cigar string to all reference cigars
279    * 
280    * @param GapChar
281    *          char
282    * @return String[]
283    */
284   public String[] getSequenceStrings(char GapChar)
285   {
286
287     if (length == 0 || refCigars == null || refCigars.length == 0)
288     {
289       return null;
290     }
291     Object[][] sqanddels = getArrayofSequenceAndDeletions(GapChar);
292     String[] seqs = new String[sqanddels.length];
293     for (int c = 0; c < refCigars.length; c++)
294     {
295       seqs[c] = (String) sqanddels[c][0];
296     }
297     return seqs;
298   }
299
300   /**
301    * Combines the CigarArray cigar operations with the operations in each
302    * reference cigar - creating a new reference cigar
303    * 
304    * @return Cigar[]
305    * 
306    *         public CigarBase[] getEditedCigars() {
307    * 
308    *         return new CigarBase[] {}; }
309    */
310   /**
311    * applyDeletions edits underlying refCigars to propagate deleted regions, and
312    * removes deletion operations from CigarArray operation list.
313    * 
314    * @return int[] position after deletion occured and range of deletion in
315    *         cigarArray or null if none occured
316    */
317   public int[] applyDeletions()
318   {
319     java.util.Vector delpos = null;
320     if (length == 0)
321     {
322       return null;
323     }
324     int cursor = 0; // range counter for deletions
325     int vcursor = 0; // visible column index
326     int offset = 0; // shift in visible column index as deletions are made
327     int i = 0;
328     while (i < length)
329     {
330       if (operation[i] != D)
331       {
332         if (operation[i] == M)
333         {
334           cursor += range[i];
335         }
336         vcursor += range[i++];
337       }
338       else
339       {
340         if (delpos == null)
341         {
342           delpos = new java.util.Vector();
343         }
344         int delstart = cursor, delend = cursor + range[i] - 1; // inclusive
345         delpos.addElement(new int[] { vcursor + offset, range[i] }); // index of
346                                                                      // right
347                                                                      // hand
348                                                                      // column
349                                                                      // after
350         // hidden region boundary
351         offset += range[i] - 1; // shift in visible column coordinates
352         System.arraycopy(operation, i + 1, operation, i, length - i);
353         System.arraycopy(range, i + 1, range, i, length - i);
354         length--;
355         /*
356          * int dmax=0; for (int s=0; s<refCigars.length; s++) { int d =
357          * refCigars[s].deleteRange(delstart, delend); if (d>dmax) dmax=d; }
358          * offset+=dmax; // shift in visible column coordinates
359          */
360         for (int s = 0; s < refCigars.length; s++)
361         {
362           int d = refCigars[s].deleteRange(delstart, delend);
363         }
364
365       }
366     }
367     if (delpos != null)
368     {
369       int[] pos = new int[delpos.size() * 2];
370       for (int k = 0, l = delpos.size(); k < l; k++)
371       {
372         int[] dr = ((int[]) delpos.elementAt(k));
373         pos[k * 2] = dr[0];
374         pos[k * 2 + 1] = dr[1];
375         delpos.setElementAt(null, k);
376       }
377       delpos = null;
378       return pos;
379     }
380     return null;
381   }
382
383   /**
384    * 
385    * @return SeqCigar[] or null if CigarArray is not a SeqCigarArray (ie it does
386    *         not resolve to set of seqCigars)
387    */
388   public SeqCigar[] getSeqCigarArray()
389   {
390     if (!isSeqCigarArray())
391     {
392       return null;
393     }
394     SeqCigar[] sa = new SeqCigar[refCigars.length];
395     for (int i = 0; i < refCigars.length; i++)
396     {
397       sa[i] = (SeqCigar) refCigars[i];
398     }
399     return sa;
400   }
401 }