JAL-2094 first pass with jalview.api.ColorI interface
[jalview.git] / src / jalview / datamodel / ColumnSelection.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 jalview.util.Comparison;
24 import jalview.util.ShiftList;
25 import jalview.viewmodel.annotationfilter.AnnotationFilterParameter;
26 import jalview.viewmodel.annotationfilter.AnnotationFilterParameter.SearchableAnnotationField;
27
28 import java.util.ArrayList;
29 import java.util.BitSet;
30 import java.util.Collections;
31 import java.util.List;
32 import java.util.Vector;
33
34 /**
35  * NOTE: Columns are zero based.
36  */
37 public class ColumnSelection
38 {
39   private class IntList
40   {
41     /*
42      * list of selected columns (ordered by selection order, not column order)
43      */
44     private List<Integer> order = new ArrayList<Integer>();
45
46     /**
47      * bitfield for column selection - allows quick lookup
48      */
49     private BitSet selected = new BitSet();
50
51     /**
52      * adds a new column i to the selection - only if i is not already selected
53      * 
54      * @param i
55      */
56     public void add(int i)
57     {
58       if (!selected.get(i))
59       {
60         order.add(Integer.valueOf(i));
61         selected.set(i);
62       }
63     }
64
65     public void clear()
66     {
67       order.clear();
68       selected.clear();
69     }
70
71     public void remove(int col)
72     {
73
74       Integer colInt = new Integer(col);
75
76       if (selected.get(col))
77       {
78         // if this ever changes to List.remove(), ensure Integer not int
79         // argument
80         // as List.remove(int i) removes the i'th item which is wrong
81         order.remove(colInt);
82         selected.clear(col);
83       }
84     }
85
86     public boolean contains(Integer colInt)
87     {
88       return selected.get(colInt);
89     }
90
91     public boolean isEmpty()
92     {
93       return order.isEmpty();
94     }
95
96     public List<Integer> getList()
97     {
98       return order;
99     }
100
101     public int size()
102     {
103       return order.size();
104     }
105
106     /**
107      * gets the column that was selected first, second or i'th
108      * 
109      * @param i
110      * @return
111      */
112     public int elementAt(int i)
113     {
114       return order.get(i);
115     }
116
117     protected boolean pruneColumnList(final List<int[]> shifts)
118     {
119       int s = 0, t = shifts.size();
120       int[] sr = shifts.get(s++);
121       boolean pruned = false;
122       int i = 0, j = order.size();
123       while (i < j && s <= t)
124       {
125         int c = order.get(i++).intValue();
126         if (sr[0] <= c)
127         {
128           if (sr[1] + sr[0] >= c)
129           { // sr[1] -ve means inseriton.
130             order.remove(--i);
131             selected.clear(c);
132             j--;
133           }
134           else
135           {
136             if (s < t)
137             {
138               sr = shifts.get(s);
139             }
140             s++;
141           }
142         }
143       }
144       return pruned;
145     }
146
147     /**
148      * shift every selected column at or above start by change
149      * 
150      * @param start
151      *          - leftmost column to be shifted
152      * @param change
153      *          - delta for shift
154      */
155     public void compensateForEdits(int start, int change)
156     {
157       BitSet mask = new BitSet();
158       for (int i = 0; i < order.size(); i++)
159       {
160         int temp = order.get(i);
161
162         if (temp >= start)
163         {
164           // clear shifted bits and update List of selected columns
165           selected.clear(temp);
166           mask.set(temp - change);
167           order.set(i, new Integer(temp - change));
168         }
169       }
170       // lastly update the bitfield all at once
171       selected.or(mask);
172     }
173
174     public boolean isSelected(int column)
175     {
176       return selected.get(column);
177     }
178
179     public int getMaxColumn()
180     {
181       return selected.length() - 1;
182     }
183
184     public int getMinColumn()
185     {
186       return selected.get(0) ? 0 : selected.nextSetBit(0);
187     }
188
189     /**
190      * @return a series of selection intervals along the range
191      */
192     public List<int[]> getRanges()
193     {
194       List<int[]> rlist = new ArrayList<int[]>();
195       if (selected.isEmpty())
196       {
197         return rlist;
198       }
199       int next = selected.nextSetBit(0), clear = -1;
200       while (next != -1)
201       {
202         clear = selected.nextClearBit(next);
203         rlist.add(new int[] { next, clear - 1 });
204         next = selected.nextSetBit(clear);
205       }
206       return rlist;
207     }
208   }
209
210   IntList selected = new IntList();
211
212   /*
213    * list of hidden column [start, end] ranges; the list is maintained in
214    * ascending start column order
215    */
216   Vector<int[]> hiddenColumns;
217
218   /**
219    * Add a column to the selection
220    * 
221    * @param col
222    *          index of column
223    */
224   public void addElement(int col)
225   {
226     selected.add(col);
227   }
228
229   /**
230    * clears column selection
231    */
232   public void clear()
233   {
234     selected.clear();
235   }
236
237   /**
238    * Removes value 'col' from the selection (not the col'th item)
239    * 
240    * @param col
241    *          index of column to be removed
242    */
243   public void removeElement(int col)
244   {
245     selected.remove(col);
246   }
247
248   /**
249    * removes a range of columns from the selection
250    * 
251    * @param start
252    *          int - first column in range to be removed
253    * @param end
254    *          int - last col
255    */
256   public void removeElements(int start, int end)
257   {
258     Integer colInt;
259     for (int i = start; i < end; i++)
260     {
261       colInt = new Integer(i);
262       if (selected.contains(colInt))
263       {
264         selected.remove(colInt);
265       }
266     }
267   }
268
269   /**
270    * Returns a list of selected columns. The list contains no duplicates but is
271    * not necessarily ordered. It also may include columns hidden from the
272    * current view
273    */
274   public List<Integer> getSelected()
275   {
276     return selected.getList();
277   }
278
279   /**
280    * @return list of int arrays containing start and end column position for
281    *         runs of selected columns ordered from right to left.
282    */
283   public List<int[]> getSelectedRanges()
284   {
285     return selected.getRanges();
286   }
287
288   /**
289    * 
290    * @param col
291    *          index to search for in column selection
292    * 
293    * @return true if col is selected
294    */
295   public boolean contains(int col)
296   {
297     return (col > -1) ? selected.isSelected(col) : false;
298   }
299
300   /**
301    * Answers true if no columns are selected, else false
302    */
303   public boolean isEmpty()
304   {
305     return selected == null || selected.isEmpty();
306   }
307
308   /**
309    * rightmost selected column
310    * 
311    * @return rightmost column in alignment that is selected
312    */
313   public int getMax()
314   {
315     if (selected.isEmpty())
316     {
317       return -1;
318     }
319     return selected.getMaxColumn();
320   }
321
322   /**
323    * Leftmost column in selection
324    * 
325    * @return column index of leftmost column in selection
326    */
327   public int getMin()
328   {
329     if (selected.isEmpty())
330     {
331       return 1000000000;
332     }
333     return selected.getMinColumn();
334   }
335
336   /**
337    * propagate shift in alignment columns to column selection
338    * 
339    * @param start
340    *          beginning of edit
341    * @param left
342    *          shift in edit (+ve for removal, or -ve for inserts)
343    */
344   public List<int[]> compensateForEdit(int start, int change)
345   {
346     List<int[]> deletedHiddenColumns = null;
347     selected.compensateForEdits(start, change);
348
349     if (hiddenColumns != null)
350     {
351       deletedHiddenColumns = new ArrayList<int[]>();
352       int hSize = hiddenColumns.size();
353       for (int i = 0; i < hSize; i++)
354       {
355         int[] region = hiddenColumns.elementAt(i);
356         if (region[0] > start && start + change > region[1])
357         {
358           deletedHiddenColumns.add(region);
359
360           hiddenColumns.removeElementAt(i);
361           i--;
362           hSize--;
363           continue;
364         }
365
366         if (region[0] > start)
367         {
368           region[0] -= change;
369           region[1] -= change;
370         }
371
372         if (region[0] < 0)
373         {
374           region[0] = 0;
375         }
376
377       }
378
379       this.revealHiddenColumns(0);
380     }
381
382     return deletedHiddenColumns;
383   }
384
385   /**
386    * propagate shift in alignment columns to column selection special version of
387    * compensateForEdit - allowing for edits within hidden regions
388    * 
389    * @param start
390    *          beginning of edit
391    * @param left
392    *          shift in edit (+ve for removal, or -ve for inserts)
393    */
394   private void compensateForDelEdits(int start, int change)
395   {
396
397     selected.compensateForEdits(start, change);
398
399     if (hiddenColumns != null)
400     {
401       for (int i = 0; i < hiddenColumns.size(); i++)
402       {
403         int[] region = hiddenColumns.elementAt(i);
404         if (region[0] >= start)
405         {
406           region[0] -= change;
407         }
408         if (region[1] >= start)
409         {
410           region[1] -= change;
411         }
412         if (region[1] < region[0])
413         {
414           hiddenColumns.removeElementAt(i--);
415         }
416
417         if (region[0] < 0)
418         {
419           region[0] = 0;
420         }
421         if (region[1] < 0)
422         {
423           region[1] = 0;
424         }
425       }
426     }
427   }
428
429   /**
430    * Adjust hidden column boundaries based on a series of column additions or
431    * deletions in visible regions.
432    * 
433    * @param shiftrecord
434    * @return
435    */
436   public ShiftList compensateForEdits(ShiftList shiftrecord)
437   {
438     if (shiftrecord != null)
439     {
440       final List<int[]> shifts = shiftrecord.getShifts();
441       if (shifts != null && shifts.size() > 0)
442       {
443         int shifted = 0;
444         for (int i = 0, j = shifts.size(); i < j; i++)
445         {
446           int[] sh = shifts.get(i);
447           // compensateForEdit(shifted+sh[0], sh[1]);
448           compensateForDelEdits(shifted + sh[0], sh[1]);
449           shifted -= sh[1];
450         }
451       }
452       return shiftrecord.getInverse();
453     }
454     return null;
455   }
456
457   /**
458    * removes intersection of position,length ranges in deletions from the
459    * start,end regions marked in intervals.
460    * 
461    * @param shifts
462    * @param intervals
463    * @return
464    */
465   private boolean pruneIntervalVector(final List<int[]> shifts,
466           Vector<int[]> intervals)
467   {
468     boolean pruned = false;
469     int i = 0, j = intervals.size() - 1, s = 0, t = shifts.size() - 1;
470     int hr[] = intervals.elementAt(i);
471     int sr[] = shifts.get(s);
472     while (i <= j && s <= t)
473     {
474       boolean trailinghn = hr[1] >= sr[0];
475       if (!trailinghn)
476       {
477         if (i < j)
478         {
479           hr = intervals.elementAt(++i);
480         }
481         else
482         {
483           i++;
484         }
485         continue;
486       }
487       int endshift = sr[0] + sr[1]; // deletion ranges - -ve means an insert
488       if (endshift < hr[0] || endshift < sr[0])
489       { // leadinghc disjoint or not a deletion
490         if (s < t)
491         {
492           sr = shifts.get(++s);
493         }
494         else
495         {
496           s++;
497         }
498         continue;
499       }
500       boolean leadinghn = hr[0] >= sr[0];
501       boolean leadinghc = hr[0] < endshift;
502       boolean trailinghc = hr[1] < endshift;
503       if (leadinghn)
504       {
505         if (trailinghc)
506         { // deleted hidden region.
507           intervals.removeElementAt(i);
508           pruned = true;
509           j--;
510           if (i <= j)
511           {
512             hr = intervals.elementAt(i);
513           }
514           continue;
515         }
516         if (leadinghc)
517         {
518           hr[0] = endshift; // clip c terminal region
519           leadinghn = !leadinghn;
520           pruned = true;
521         }
522       }
523       if (!leadinghn)
524       {
525         if (trailinghc)
526         {
527           if (trailinghn)
528           {
529             hr[1] = sr[0] - 1;
530             pruned = true;
531           }
532         }
533         else
534         {
535           // sr contained in hr
536           if (s < t)
537           {
538             sr = shifts.get(++s);
539           }
540           else
541           {
542             s++;
543           }
544           continue;
545         }
546       }
547     }
548     return pruned; // true if any interval was removed or modified by
549     // operations.
550   }
551
552   /**
553    * remove any hiddenColumns or selected columns and shift remaining based on a
554    * series of position, range deletions.
555    * 
556    * @param deletions
557    */
558   public void pruneDeletions(ShiftList deletions)
559   {
560     if (deletions != null)
561     {
562       final List<int[]> shifts = deletions.getShifts();
563       if (shifts != null && shifts.size() > 0)
564       {
565         // delete any intervals intersecting.
566         if (hiddenColumns != null)
567         {
568           pruneIntervalVector(shifts, hiddenColumns);
569           if (hiddenColumns != null && hiddenColumns.size() == 0)
570           {
571             hiddenColumns = null;
572           }
573         }
574         if (selected != null && selected.size() > 0)
575         {
576           selected.pruneColumnList(shifts);
577           if (selected != null && selected.size() == 0)
578           {
579             selected = null;
580           }
581         }
582         // and shift the rest.
583         this.compensateForEdits(deletions);
584       }
585     }
586   }
587
588   /**
589    * This Method is used to return all the HiddenColumn regions
590    * 
591    * @return empty list or List of hidden column intervals
592    */
593   public List<int[]> getHiddenColumns()
594   {
595     return hiddenColumns == null ? Collections.<int[]> emptyList()
596             : hiddenColumns;
597   }
598
599   /**
600    * Return absolute column index for a visible column index
601    * 
602    * @param column
603    *          int column index in alignment view
604    * @return alignment column index for column
605    */
606   public int adjustForHiddenColumns(int column)
607   {
608     int result = column;
609     if (hiddenColumns != null)
610     {
611       for (int i = 0; i < hiddenColumns.size(); i++)
612       {
613         int[] region = hiddenColumns.elementAt(i);
614         if (result >= region[0])
615         {
616           result += region[1] - region[0] + 1;
617         }
618       }
619     }
620     return result;
621   }
622
623   /**
624    * Use this method to find out where a column will appear in the visible
625    * alignment when hidden columns exist. If the column is not visible, then the
626    * left-most visible column will always be returned.
627    * 
628    * @param hiddenColumn
629    *          int
630    * @return int
631    */
632   public int findColumnPosition(int hiddenColumn)
633   {
634     int result = hiddenColumn;
635     if (hiddenColumns != null)
636     {
637       int index = 0;
638       int[] region;
639       do
640       {
641         region = hiddenColumns.elementAt(index++);
642         if (hiddenColumn > region[1])
643         {
644           result -= region[1] + 1 - region[0];
645         }
646       } while ((hiddenColumn > region[1]) && (index < hiddenColumns.size()));
647       if (hiddenColumn > region[0] && hiddenColumn < region[1])
648       {
649         return region[0] + hiddenColumn - result;
650       }
651     }
652     return result; // return the shifted position after removing hidden columns.
653   }
654
655   /**
656    * Use this method to determine where the next hiddenRegion starts
657    * 
658    * @param hiddenRegion
659    *          index of hidden region (counts from 0)
660    * @return column number in visible view
661    */
662   public int findHiddenRegionPosition(int hiddenRegion)
663   {
664     int result = 0;
665     if (hiddenColumns != null)
666     {
667       int index = 0;
668       int gaps = 0;
669       do
670       {
671         int[] region = hiddenColumns.elementAt(index);
672         if (hiddenRegion == 0)
673         {
674           return region[0];
675         }
676
677         gaps += region[1] + 1 - region[0];
678         result = region[1] + 1;
679         index++;
680       } while (index <= hiddenRegion);
681
682       result -= gaps;
683     }
684
685     return result;
686   }
687
688   /**
689    * THis method returns the rightmost limit of a region of an alignment with
690    * hidden columns. In otherwords, the next hidden column.
691    * 
692    * @param index
693    *          int
694    */
695   public int getHiddenBoundaryRight(int alPos)
696   {
697     if (hiddenColumns != null)
698     {
699       int index = 0;
700       do
701       {
702         int[] region = hiddenColumns.elementAt(index);
703         if (alPos < region[0])
704         {
705           return region[0];
706         }
707
708         index++;
709       } while (index < hiddenColumns.size());
710     }
711
712     return alPos;
713
714   }
715
716   /**
717    * This method returns the leftmost limit of a region of an alignment with
718    * hidden columns. In otherwords, the previous hidden column.
719    * 
720    * @param index
721    *          int
722    */
723   public int getHiddenBoundaryLeft(int alPos)
724   {
725     if (hiddenColumns != null)
726     {
727       int index = hiddenColumns.size() - 1;
728       do
729       {
730         int[] region = hiddenColumns.elementAt(index);
731         if (alPos > region[1])
732         {
733           return region[1];
734         }
735
736         index--;
737       } while (index > -1);
738     }
739
740     return alPos;
741
742   }
743
744   public void hideSelectedColumns()
745   {
746     synchronized (selected)
747     {
748       for (int[] selregions : selected.getRanges())
749       {
750         hideColumns(selregions[0], selregions[1]);
751       }
752       selected.clear();
753     }
754
755   }
756
757   /**
758    * Adds the specified column range to the hidden columns
759    * 
760    * @param start
761    * @param end
762    */
763   public void hideColumns(int start, int end)
764   {
765     if (hiddenColumns == null)
766     {
767       hiddenColumns = new Vector<int[]>();
768     }
769
770     /*
771      * traverse existing hidden ranges and insert / amend / append as
772      * appropriate
773      */
774     for (int i = 0; i < hiddenColumns.size(); i++)
775     {
776       int[] region = hiddenColumns.elementAt(i);
777
778       if (end < region[0] - 1)
779       {
780         /*
781          * insert discontiguous preceding range
782          */
783         hiddenColumns.insertElementAt(new int[] { start, end }, i);
784         return;
785       }
786
787       if (end <= region[1])
788       {
789         /*
790          * new range overlaps existing, or is contiguous preceding it - adjust
791          * start column
792          */
793         region[0] = Math.min(region[0], start);
794         return;
795       }
796
797       if (start <= region[1] + 1)
798       {
799         /*
800          * new range overlaps existing, or is contiguous following it - adjust
801          * start and end columns
802          */
803         region[0] = Math.min(region[0], start);
804         region[1] = Math.max(region[1], end);
805         return;
806       }
807     }
808
809     /*
810      * remaining case is that the new range follows everything else
811      */
812     hiddenColumns.addElement(new int[] { start, end });
813   }
814
815   /**
816    * Hides the specified column and any adjacent selected columns
817    * 
818    * @param res
819    *          int
820    */
821   public void hideColumns(int col)
822   {
823     /*
824      * deselect column (whether selected or not!)
825      */
826     removeElement(col);
827
828     /*
829      * find adjacent selected columns
830      */
831     int min = col - 1, max = col + 1;
832     while (contains(min))
833     {
834       removeElement(min);
835       min--;
836     }
837
838     while (contains(max))
839     {
840       removeElement(max);
841       max++;
842     }
843
844     /*
845      * min, max are now the closest unselected columns
846      */
847     min++;
848     max--;
849     if (min > max)
850     {
851       min = max;
852     }
853
854     hideColumns(min, max);
855   }
856
857   /**
858    * Unhides, and adds to the selection list, all hidden columns
859    */
860   public void revealAllHiddenColumns()
861   {
862     if (hiddenColumns != null)
863     {
864       for (int i = 0; i < hiddenColumns.size(); i++)
865       {
866         int[] region = hiddenColumns.elementAt(i);
867         for (int j = region[0]; j < region[1] + 1; j++)
868         {
869           addElement(j);
870         }
871       }
872     }
873
874     hiddenColumns = null;
875   }
876
877   /**
878    * Reveals, and marks as selected, the hidden column range with the given
879    * start column
880    * 
881    * @param start
882    */
883   public void revealHiddenColumns(int start)
884   {
885     for (int i = 0; i < hiddenColumns.size(); i++)
886     {
887       int[] region = hiddenColumns.elementAt(i);
888       if (start == region[0])
889       {
890         for (int j = region[0]; j < region[1] + 1; j++)
891         {
892           addElement(j);
893         }
894
895         hiddenColumns.removeElement(region);
896         break;
897       }
898     }
899     if (hiddenColumns.size() == 0)
900     {
901       hiddenColumns = null;
902     }
903   }
904
905   public boolean isVisible(int column)
906   {
907     if (hiddenColumns != null)
908     {
909       for (int[] region : hiddenColumns)
910       {
911         if (column >= region[0] && column <= region[1])
912         {
913           return false;
914         }
915       }
916     }
917
918     return true;
919   }
920
921   /**
922    * Copy constructor
923    * 
924    * @param copy
925    */
926   public ColumnSelection(ColumnSelection copy)
927   {
928     if (copy != null)
929     {
930       if (copy.selected != null)
931       {
932         selected = new IntList();
933         for (int i = 0, j = copy.selected.size(); i < j; i++)
934         {
935           selected.add(copy.selected.elementAt(i));
936         }
937       }
938       if (copy.hiddenColumns != null)
939       {
940         hiddenColumns = new Vector<int[]>(copy.hiddenColumns.size());
941         for (int i = 0, j = copy.hiddenColumns.size(); i < j; i++)
942         {
943           int[] rh, cp;
944           rh = copy.hiddenColumns.elementAt(i);
945           if (rh != null)
946           {
947             cp = new int[rh.length];
948             System.arraycopy(rh, 0, cp, 0, rh.length);
949             hiddenColumns.addElement(cp);
950           }
951         }
952       }
953     }
954   }
955
956   /**
957    * ColumnSelection
958    */
959   public ColumnSelection()
960   {
961   }
962
963   public String[] getVisibleSequenceStrings(int start, int end,
964           SequenceI[] seqs)
965   {
966     int i, iSize = seqs.length;
967     String selection[] = new String[iSize];
968     if (hiddenColumns != null && hiddenColumns.size() > 0)
969     {
970       for (i = 0; i < iSize; i++)
971       {
972         StringBuffer visibleSeq = new StringBuffer();
973         List<int[]> regions = getHiddenColumns();
974
975         int blockStart = start, blockEnd = end;
976         int[] region;
977         int hideStart, hideEnd;
978
979         for (int j = 0; j < regions.size(); j++)
980         {
981           region = regions.get(j);
982           hideStart = region[0];
983           hideEnd = region[1];
984
985           if (hideStart < start)
986           {
987             continue;
988           }
989
990           blockStart = Math.min(blockStart, hideEnd + 1);
991           blockEnd = Math.min(blockEnd, hideStart);
992
993           if (blockStart > blockEnd)
994           {
995             break;
996           }
997
998           visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd));
999
1000           blockStart = hideEnd + 1;
1001           blockEnd = end;
1002         }
1003
1004         if (end > blockStart)
1005         {
1006           visibleSeq.append(seqs[i].getSequence(blockStart, end));
1007         }
1008
1009         selection[i] = visibleSeq.toString();
1010       }
1011     }
1012     else
1013     {
1014       for (i = 0; i < iSize; i++)
1015       {
1016         selection[i] = seqs[i].getSequenceAsString(start, end);
1017       }
1018     }
1019
1020     return selection;
1021   }
1022
1023   /**
1024    * return all visible segments between the given start and end boundaries
1025    * 
1026    * @param start
1027    *          (first column inclusive from 0)
1028    * @param end
1029    *          (last column - not inclusive)
1030    * @return int[] {i_start, i_end, ..} where intervals lie in
1031    *         start<=i_start<=i_end<end
1032    */
1033   public int[] getVisibleContigs(int start, int end)
1034   {
1035     if (hiddenColumns != null && hiddenColumns.size() > 0)
1036     {
1037       List<int[]> visiblecontigs = new ArrayList<int[]>();
1038       List<int[]> regions = getHiddenColumns();
1039
1040       int vstart = start;
1041       int[] region;
1042       int hideStart, hideEnd;
1043
1044       for (int j = 0; vstart < end && j < regions.size(); j++)
1045       {
1046         region = regions.get(j);
1047         hideStart = region[0];
1048         hideEnd = region[1];
1049
1050         if (hideEnd < vstart)
1051         {
1052           continue;
1053         }
1054         if (hideStart > vstart)
1055         {
1056           visiblecontigs.add(new int[] { vstart, hideStart - 1 });
1057         }
1058         vstart = hideEnd + 1;
1059       }
1060
1061       if (vstart < end)
1062       {
1063         visiblecontigs.add(new int[] { vstart, end - 1 });
1064       }
1065       int[] vcontigs = new int[visiblecontigs.size() * 2];
1066       for (int i = 0, j = visiblecontigs.size(); i < j; i++)
1067       {
1068         int[] vc = visiblecontigs.get(i);
1069         visiblecontigs.set(i, null);
1070         vcontigs[i * 2] = vc[0];
1071         vcontigs[i * 2 + 1] = vc[1];
1072       }
1073       visiblecontigs.clear();
1074       return vcontigs;
1075     }
1076     else
1077     {
1078       return new int[] { start, end - 1 };
1079     }
1080   }
1081
1082   /**
1083    * Locate the first and last position visible for this sequence. if seq isn't
1084    * visible then return the position of the left and right of the hidden
1085    * boundary region, and the corresponding alignment column indices for the
1086    * extent of the sequence
1087    * 
1088    * @param seq
1089    * @return int[] { visible start, visible end, first seqpos, last seqpos,
1090    *         alignment index for seq start, alignment index for seq end }
1091    */
1092   public int[] locateVisibleBoundsOfSequence(SequenceI seq)
1093   {
1094     int fpos=seq.getStart(),lpos= seq.getEnd();
1095     int start = 0;
1096     
1097     if (hiddenColumns == null || hiddenColumns.size() == 0)
1098     {
1099       int ifpos = seq.findIndex(fpos) - 1, ilpos = seq.findIndex(lpos) - 1;
1100       return new int[] { ifpos, ilpos, fpos, lpos, ifpos, ilpos };
1101     }
1102
1103     // Simply walk along the sequence whilst watching for hidden column
1104     // boundaries
1105     List<int[]> regions = getHiddenColumns();
1106     int spos = fpos, lastvispos = -1, rcount = 0, hideStart = seq
1107             .getLength(), hideEnd = -1;
1108     int visPrev = 0, visNext = 0, firstP = -1, lastP = -1;
1109     boolean foundStart = false;
1110     for (int p = 0, pLen = seq.getLength(); spos <= seq.getEnd()
1111             && p < pLen; p++)
1112     {
1113       if (!Comparison.isGap(seq.getCharAt(p)))
1114       {
1115         // keep track of first/last column
1116         // containing sequence data regardless of visibility
1117         if (firstP == -1)
1118         {
1119           firstP = p;
1120         }
1121         lastP = p;
1122         // update hidden region start/end
1123         while (hideEnd < p && rcount < regions.size())
1124         {
1125           int[] region = regions.get(rcount++);
1126           visPrev = visNext;
1127           visNext += region[0] - visPrev;
1128           hideStart = region[0];
1129           hideEnd = region[1];
1130         }
1131         if (hideEnd < p)
1132         {
1133           hideStart = seq.getLength();
1134         }
1135         // update visible boundary for sequence
1136         if (p < hideStart)
1137         {
1138           if (!foundStart)
1139           {
1140             fpos = spos;
1141             start = p;
1142             foundStart = true;
1143           }
1144           lastvispos = p;
1145           lpos = spos;
1146         }
1147         // look for next sequence position
1148         spos++;
1149       }
1150     }
1151     if (foundStart)
1152     {
1153       return new int[] { findColumnPosition(start),
1154           findColumnPosition(lastvispos), fpos, lpos, firstP, lastP };
1155     }
1156     // otherwise, sequence was completely hidden
1157     return new int[] { visPrev, visNext, 0, 0, firstP, lastP };
1158   }
1159
1160   /**
1161    * delete any columns in alignmentAnnotation that are hidden (including
1162    * sequence associated annotation).
1163    * 
1164    * @param alignmentAnnotation
1165    */
1166   public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation)
1167   {
1168     makeVisibleAnnotation(-1, -1, alignmentAnnotation);
1169   }
1170
1171   /**
1172    * delete any columns in alignmentAnnotation that are hidden (including
1173    * sequence associated annotation).
1174    * 
1175    * @param start
1176    *          remove any annotation to the right of this column
1177    * @param end
1178    *          remove any annotation to the left of this column
1179    * @param alignmentAnnotation
1180    *          the annotation to operate on
1181    */
1182   public void makeVisibleAnnotation(int start, int end,
1183           AlignmentAnnotation alignmentAnnotation)
1184   {
1185     if (alignmentAnnotation.annotations == null)
1186     {
1187       return;
1188     }
1189     if (start == end && end == -1)
1190     {
1191       start = 0;
1192       end = alignmentAnnotation.annotations.length;
1193     }
1194     if (hiddenColumns != null && hiddenColumns.size() > 0)
1195     {
1196       // then mangle the alignmentAnnotation annotation array
1197       Vector<Annotation[]> annels = new Vector<Annotation[]>();
1198       Annotation[] els = null;
1199       List<int[]> regions = getHiddenColumns();
1200       int blockStart = start, blockEnd = end;
1201       int[] region;
1202       int hideStart, hideEnd, w = 0;
1203
1204       for (int j = 0; j < regions.size(); j++)
1205       {
1206         region = regions.get(j);
1207         hideStart = region[0];
1208         hideEnd = region[1];
1209
1210         if (hideStart < start)
1211         {
1212           continue;
1213         }
1214
1215         blockStart = Math.min(blockStart, hideEnd + 1);
1216         blockEnd = Math.min(blockEnd, hideStart);
1217
1218         if (blockStart > blockEnd)
1219         {
1220           break;
1221         }
1222
1223         annels.addElement(els = new Annotation[blockEnd - blockStart]);
1224         System.arraycopy(alignmentAnnotation.annotations, blockStart, els,
1225                 0, els.length);
1226         w += els.length;
1227         blockStart = hideEnd + 1;
1228         blockEnd = end;
1229       }
1230
1231       if (end > blockStart)
1232       {
1233         annels.addElement(els = new Annotation[end - blockStart + 1]);
1234         if ((els.length + blockStart) <= alignmentAnnotation.annotations.length)
1235         {
1236           // copy just the visible segment of the annotation row
1237           System.arraycopy(alignmentAnnotation.annotations, blockStart,
1238                   els, 0, els.length);
1239         }
1240         else
1241         {
1242           // copy to the end of the annotation row
1243           System.arraycopy(alignmentAnnotation.annotations, blockStart,
1244                   els, 0,
1245                   (alignmentAnnotation.annotations.length - blockStart));
1246         }
1247         w += els.length;
1248       }
1249       if (w == 0)
1250       {
1251         return;
1252       }
1253
1254       alignmentAnnotation.annotations = new Annotation[w];
1255       w = 0;
1256
1257       for (Annotation[] chnk : annels)
1258       {
1259         System.arraycopy(chnk, 0, alignmentAnnotation.annotations, w,
1260                 chnk.length);
1261         w += chnk.length;
1262       }
1263     }
1264     else
1265     {
1266       alignmentAnnotation.restrict(start, end);
1267     }
1268   }
1269
1270   /**
1271    * Invert the column selection from first to end-1. leaves hiddenColumns
1272    * untouched (and unselected)
1273    * 
1274    * @param first
1275    * @param end
1276    */
1277   public void invertColumnSelection(int first, int width)
1278   {
1279     boolean hasHidden = hiddenColumns != null && hiddenColumns.size() > 0;
1280     for (int i = first; i < width; i++)
1281     {
1282       if (contains(i))
1283       {
1284         removeElement(i);
1285       }
1286       else
1287       {
1288         if (!hasHidden || isVisible(i))
1289         {
1290           addElement(i);
1291         }
1292       }
1293     }
1294   }
1295
1296   /**
1297    * add in any unselected columns from the given column selection, excluding
1298    * any that are hidden.
1299    * 
1300    * @param colsel
1301    */
1302   public void addElementsFrom(ColumnSelection colsel)
1303   {
1304     if (colsel != null && !colsel.isEmpty())
1305     {
1306       for (Integer col : colsel.getSelected())
1307       {
1308         if (hiddenColumns != null && isVisible(col.intValue()))
1309         {
1310           selected.add(col);
1311         }
1312       }
1313     }
1314   }
1315
1316   /**
1317    * set the selected columns the given column selection, excluding any columns
1318    * that are hidden.
1319    * 
1320    * @param colsel
1321    */
1322   public void setElementsFrom(ColumnSelection colsel)
1323   {
1324     selected = new IntList();
1325     if (colsel.selected != null && colsel.selected.size() > 0)
1326     {
1327       if (hiddenColumns != null && hiddenColumns.size() > 0)
1328       {
1329         // only select visible columns in this columns selection
1330         addElementsFrom(colsel);
1331       }
1332       else
1333       {
1334         // add everything regardless
1335         for (Integer col : colsel.getSelected())
1336         {
1337           addElement(col);
1338         }
1339       }
1340     }
1341   }
1342
1343   /**
1344    * Add gaps into the sequences aligned to profileseq under the given
1345    * AlignmentView
1346    * 
1347    * @param profileseq
1348    * @param al
1349    *          - alignment to have gaps inserted into it
1350    * @param input
1351    *          - alignment view where sequence corresponding to profileseq is
1352    *          first entry
1353    * @return new Column selection for new alignment view, with insertions into
1354    *         profileseq marked as hidden.
1355    */
1356   public static ColumnSelection propagateInsertions(SequenceI profileseq,
1357           AlignmentI al, AlignmentView input)
1358   {
1359     int profsqpos = 0;
1360
1361     // return propagateInsertions(profileseq, al, )
1362     char gc = al.getGapCharacter();
1363     Object[] alandcolsel = input.getAlignmentAndColumnSelection(gc);
1364     ColumnSelection nview = (ColumnSelection) alandcolsel[1];
1365     SequenceI origseq = ((SequenceI[]) alandcolsel[0])[profsqpos];
1366     nview.propagateInsertions(profileseq, al, origseq);
1367     return nview;
1368   }
1369
1370   /**
1371    * 
1372    * @param profileseq
1373    *          - sequence in al which corresponds to origseq
1374    * @param al
1375    *          - alignment which is to have gaps inserted into it
1376    * @param origseq
1377    *          - sequence corresponding to profileseq which defines gap map for
1378    *          modifying al
1379    */
1380   public void propagateInsertions(SequenceI profileseq, AlignmentI al,
1381           SequenceI origseq)
1382   {
1383     char gc = al.getGapCharacter();
1384     // recover mapping between sequence's non-gap positions and positions
1385     // mapping to view.
1386     pruneDeletions(ShiftList.parseMap(origseq.gapMap()));
1387     int[] viscontigs = getVisibleContigs(0, profileseq.getLength());
1388     int spos = 0;
1389     int offset = 0;
1390     // input.pruneDeletions(ShiftList.parseMap(((SequenceI[])
1391     // alandcolsel[0])[0].gapMap()))
1392     // add profile to visible contigs
1393     for (int v = 0; v < viscontigs.length; v += 2)
1394     {
1395       if (viscontigs[v] > spos)
1396       {
1397         StringBuffer sb = new StringBuffer();
1398         for (int s = 0, ns = viscontigs[v] - spos; s < ns; s++)
1399         {
1400           sb.append(gc);
1401         }
1402         for (int s = 0, ns = al.getHeight(); s < ns; s++)
1403         {
1404           SequenceI sqobj = al.getSequenceAt(s);
1405           if (sqobj != profileseq)
1406           {
1407             String sq = al.getSequenceAt(s).getSequenceAsString();
1408             if (sq.length() <= spos + offset)
1409             {
1410               // pad sequence
1411               int diff = spos + offset - sq.length() - 1;
1412               if (diff > 0)
1413               {
1414                 // pad gaps
1415                 sq = sq + sb;
1416                 while ((diff = spos + offset - sq.length() - 1) > 0)
1417                 {
1418                   // sq = sq
1419                   // + ((diff >= sb.length()) ? sb.toString() : sb
1420                   // .substring(0, diff));
1421                   if (diff >= sb.length())
1422                   {
1423                     sq += sb.toString();
1424                   }
1425                   else
1426                   {
1427                     char[] buf = new char[diff];
1428                     sb.getChars(0, diff, buf, 0);
1429                     sq += buf.toString();
1430                   }
1431                 }
1432               }
1433               sq += sb.toString();
1434             }
1435             else
1436             {
1437               al.getSequenceAt(s).setSequence(
1438                       sq.substring(0, spos + offset) + sb.toString()
1439                               + sq.substring(spos + offset));
1440             }
1441           }
1442         }
1443         // offset+=sb.length();
1444       }
1445       spos = viscontigs[v + 1] + 1;
1446     }
1447     if ((offset + spos) < profileseq.getLength())
1448     {
1449       // pad the final region with gaps.
1450       StringBuffer sb = new StringBuffer();
1451       for (int s = 0, ns = profileseq.getLength() - spos - offset; s < ns; s++)
1452       {
1453         sb.append(gc);
1454       }
1455       for (int s = 0, ns = al.getHeight(); s < ns; s++)
1456       {
1457         SequenceI sqobj = al.getSequenceAt(s);
1458         if (sqobj == profileseq)
1459         {
1460           continue;
1461         }
1462         String sq = sqobj.getSequenceAsString();
1463         // pad sequence
1464         int diff = origseq.getLength() - sq.length();
1465         while (diff > 0)
1466         {
1467           // sq = sq
1468           // + ((diff >= sb.length()) ? sb.toString() : sb
1469           // .substring(0, diff));
1470           if (diff >= sb.length())
1471           {
1472             sq += sb.toString();
1473           }
1474           else
1475           {
1476             char[] buf = new char[diff];
1477             sb.getChars(0, diff, buf, 0);
1478             sq += buf.toString();
1479           }
1480           diff = origseq.getLength() - sq.length();
1481         }
1482       }
1483     }
1484   }
1485
1486   /**
1487    * 
1488    * @return true if there are columns marked
1489    */
1490   public boolean hasSelectedColumns()
1491   {
1492     return (selected != null && selected.size() > 0);
1493   }
1494
1495   /**
1496    * 
1497    * @return true if there are columns hidden
1498    */
1499   public boolean hasHiddenColumns()
1500   {
1501     return hiddenColumns != null && hiddenColumns.size() > 0;
1502   }
1503
1504   /**
1505    * 
1506    * @return true if there are more than one set of columns hidden
1507    */
1508   public boolean hasManyHiddenColumns()
1509   {
1510     return hiddenColumns != null && hiddenColumns.size() > 1;
1511   }
1512
1513   /**
1514    * mark the columns corresponding to gap characters as hidden in the column
1515    * selection
1516    * 
1517    * @param sr
1518    */
1519   public void hideInsertionsFor(SequenceI sr)
1520   {
1521     List<int[]> inserts = sr.getInsertions();
1522     for (int[] r : inserts)
1523     {
1524       hideColumns(r[0], r[1]);
1525     }
1526   }
1527
1528   public boolean filterAnnotations(Annotation[] annotations,
1529           AnnotationFilterParameter filterParams)
1530   {
1531     // JBPNote - this method needs to be refactored to become independent of
1532     // viewmodel package
1533     this.revealAllHiddenColumns();
1534     this.clear();
1535     int count = 0;
1536     do
1537     {
1538       if (annotations[count] != null)
1539       {
1540
1541         boolean itemMatched = false;
1542
1543         if (filterParams.getThresholdType() == AnnotationFilterParameter.ThresholdType.ABOVE_THRESHOLD
1544                 && annotations[count].value >= filterParams
1545                         .getThresholdValue())
1546         {
1547           itemMatched = true;
1548         }
1549         if (filterParams.getThresholdType() == AnnotationFilterParameter.ThresholdType.BELOW_THRESHOLD
1550                 && annotations[count].value <= filterParams
1551                         .getThresholdValue())
1552         {
1553           itemMatched = true;
1554         }
1555
1556         if (filterParams.isFilterAlphaHelix()
1557                 && annotations[count].secondaryStructure == 'H')
1558         {
1559           itemMatched = true;
1560         }
1561
1562         if (filterParams.isFilterBetaSheet()
1563                 && annotations[count].secondaryStructure == 'E')
1564         {
1565           itemMatched = true;
1566         }
1567
1568         if (filterParams.isFilterTurn()
1569                 && annotations[count].secondaryStructure == 'S')
1570         {
1571           itemMatched = true;
1572         }
1573
1574         String regexSearchString = filterParams.getRegexString();
1575         if (regexSearchString != null
1576                 && !filterParams.getRegexSearchFields().isEmpty())
1577         {
1578           List<SearchableAnnotationField> fields = filterParams
1579                   .getRegexSearchFields();
1580           try
1581           {
1582             if (fields.contains(SearchableAnnotationField.DISPLAY_STRING)
1583                     && annotations[count].displayCharacter
1584                             .matches(regexSearchString))
1585             {
1586               itemMatched = true;
1587             }
1588           } catch (java.util.regex.PatternSyntaxException pse)
1589           {
1590             if (annotations[count].displayCharacter
1591                     .equals(regexSearchString))
1592             {
1593               itemMatched = true;
1594             }
1595           }
1596           if (fields.contains(SearchableAnnotationField.DESCRIPTION)
1597                   && annotations[count].description != null
1598                   && annotations[count].description
1599                           .matches(regexSearchString))
1600           {
1601             itemMatched = true;
1602           }
1603         }
1604
1605         if (itemMatched)
1606         {
1607           this.addElement(count);
1608         }
1609       }
1610       count++;
1611     } while (count < annotations.length);
1612     return false;
1613   }
1614
1615 }