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