src/jalview/controller/AlignViewController.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.controller;
  22
  23 import jalview.analysis.AlignmentSorter;
  24 import jalview.api.AlignViewControllerGuiI;
  25 import jalview.api.AlignViewControllerI;
  26 import jalview.api.AlignViewportI;
  27 import jalview.api.AlignmentViewPanel;
  28 import jalview.api.FeatureRenderer;
  29 import jalview.commands.OrderCommand;
  30 import jalview.datamodel.AlignmentI;
  31 import jalview.datamodel.ColumnSelection;
  32 import jalview.datamodel.SequenceCollectionI;
  33 import jalview.datamodel.SequenceFeature;
  34 import jalview.datamodel.SequenceGroup;
  35 import jalview.datamodel.SequenceI;
  36 import jalview.io.DataSourceType;
  37 import jalview.io.FeaturesFile;
  38 import jalview.util.MessageManager;
  39
  40 import java.awt.Color;
  41 import java.util.Arrays;
  42 import java.util.BitSet;
  43 import java.util.List;
  44
  45 public class AlignViewController implements AlignViewControllerI
  46 {
  47   AlignViewportI viewport = null;
  48
  49   AlignmentViewPanel alignPanel = null;
  50
  51   /**
  52    * the GUI container that is handling interactions with the user
  53    */
  54   private AlignViewControllerGuiI avcg;
  55
  56   @Override
  57   protected void finalize() throws Throwable
  58   {
  59     viewport = null;
  60     alignPanel = null;
  61     avcg = null;
  62   };
  63
  64   public AlignViewController(AlignViewControllerGuiI alignFrame,
  65           AlignViewportI viewport, AlignmentViewPanel alignPanel)
  66   {
  67     this.avcg = alignFrame;
  68     this.viewport = viewport;
  69     this.alignPanel = alignPanel;
  70   }
  71
  72   @Override
  73   public void setViewportAndAlignmentPanel(AlignViewportI viewport,
  74           AlignmentViewPanel alignPanel)
  75   {
  76     this.alignPanel = alignPanel;
  77     this.viewport = viewport;
  78
  79   }
  80
  81   @Override
  82   public boolean makeGroupsFromSelection()
  83   {
  84     SequenceGroup sg = viewport.getSelectionGroup();
  85     ColumnSelection cs = viewport.getColumnSelection();
  86     SequenceGroup[] gps = null;
  87     if (sg != null && (cs == null || cs.isEmpty()))
  88     {
  89       gps = jalview.analysis.Grouping.makeGroupsFrom(viewport
  90               .getSequenceSelection(), viewport.getAlignmentView(true)
  91               .getSequenceStrings(viewport.getGapCharacter()), viewport
  92               .getAlignment().getGroups());
  93     }
  94     else
  95     {
  96       if (cs != null)
  97       {
  98         gps = jalview.analysis.Grouping.makeGroupsFromCols(
  99                 (sg == null) ? viewport.getAlignment().getSequencesArray()
 100                         : sg.getSequences().toArray(new SequenceI[0]), cs,
 101                 viewport.getAlignment().getGroups());
 102       }
 103     }
 104     if (gps != null)
 105     {
 106       showRandomColoursForGroups(Arrays.asList(gps));
 107
 108       return true;
 109     }
 110     return false;
 111   }
 112
 113   @Override
 114   public void showRandomColoursForGroups(List<SequenceGroup> gps)
 115   {
 116     viewport.getAlignment().deleteAllGroups();
 117     viewport.clearSequenceColours();
 118     viewport.setSelectionGroup(null);
 119     // set view properties for each group
 120     for (SequenceGroup sg : gps)
 121     {
 122       // gps[g].setShowunconserved(viewport.getShowUnconserved());
 123       sg.setshowSequenceLogo(viewport.isShowSequenceLogo());
 124       viewport.getAlignment().addGroup(sg);
 125       Color col = new Color((int) (Math.random() * 255),
 126               (int) (Math.random() * 255), (int) (Math.random() * 255));
 127       col = col.brighter();
 128       for (SequenceI sq : sg.getSequences(null))
 129       {
 130         viewport.setSequenceColour(sq, col);
 131       }
 132     }
 133   }
 134
 135   @Override
 136   public boolean createGroup()
 137   {
 138
 139     SequenceGroup sg = viewport.getSelectionGroup();
 140     if (sg != null)
 141     {
 142       viewport.getAlignment().addGroup(sg);
 143       return true;
 144     }
 145     return false;
 146   }
 147
 148   @Override
 149   public boolean unGroup()
 150   {
 151     SequenceGroup sg = viewport.getSelectionGroup();
 152     if (sg != null)
 153     {
 154       viewport.getAlignment().deleteGroup(sg);
 155       return true;
 156     }
 157     return false;
 158   }
 159
 160   @Override
 161   public boolean deleteGroups()
 162   {
 163     if (viewport.getAlignment().getGroups() != null
 164             && viewport.getAlignment().getGroups().size() > 0)
 165     {
 166       viewport.getAlignment().deleteAllGroups();
 167       viewport.clearSequenceColours();
 168       viewport.setSelectionGroup(null);
 169       return true;
 170     }
 171     return false;
 172   }
 173
 174   @Override
 175   public boolean markColumnsContainingFeatures(boolean invert,
 176           boolean extendCurrent, boolean toggle, String featureType)
 177   {
 178     // JBPNote this routine could also mark rows, not just columns.
 179     // need a decent query structure to allow all types of feature searches
 180     BitSet bs = new BitSet();
 181     SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null || extendCurrent) ? viewport
 182             .getAlignment() : viewport.getSelectionGroup();
 183
 184     int nseq = findColumnsWithFeature(featureType, sqcol, bs);
 185
 186     ColumnSelection cs = viewport.getColumnSelection();
 187     if (cs == null)
 188     {
 189       cs = new ColumnSelection();
 190     }
 191
 192     if (bs.cardinality() > 0 || invert)
 193     {
 194       boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
 195               sqcol.getEndRes(), invert, extendCurrent, toggle);
 196       if (changed)
 197       {
 198         viewport.setColumnSelection(cs);
 199         alignPanel.paintAlignment(true);
 200         int columnCount = invert ? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
 201                 - bs.cardinality()
 202                 : bs.cardinality();
 203         avcg.setStatus(MessageManager.formatMessage(
 204                 "label.view_controller_toggled_marked",
 205                 new String[] {
 206                     toggle ? MessageManager.getString("label.toggled")
 207                             : MessageManager.getString("label.marked"),
 208                     String.valueOf(columnCount),
 209                     invert ? MessageManager
 210                             .getString("label.not_containing")
 211                             : MessageManager.getString("label.containing"),
 212                     featureType, Integer.valueOf(nseq).toString() }));
 213         return true;
 214       }
 215     }
 216     else
 217     {
 218       avcg.setStatus(MessageManager.formatMessage(
 219               "label.no_feature_of_type_found",
 220               new String[] { featureType }));
 221       if (!extendCurrent)
 222       {
 223         cs.clear();
 224         alignPanel.paintAlignment(true);
 225       }
 226     }
 227     return false;
 228   }
 229
 230   /**
 231    * Sets a bit in the BitSet for each column (base 0) in the sequence
 232    * collection which includes the specified feature type. Returns the number of
 233    * sequences which have the feature in the selected range.
 234    *
 235    * @param featureType
 236    * @param sqcol
 237    * @param bs
 238    * @return
 239    */
 240   static int findColumnsWithFeature(String featureType,
 241           SequenceCollectionI sqcol, BitSet bs)
 242   {
 243     final int startPosition = sqcol.getStartRes() + 1; // converted to base 1
 244     final int endPosition = sqcol.getEndRes() + 1;
 245     List<SequenceI> seqs = sqcol.getSequences();
 246     int nseq = 0;
 247     for (SequenceI sq : seqs)
 248     {
 249       boolean sequenceHasFeature = false;
 250       if (sq != null)
 251       {
 252         SequenceFeature[] sfs = sq.getSequenceFeatures();
 253         if (sfs != null)
 254         {
 255           int ist = sq.findIndex(sq.getStart());
 256           int iend = sq.findIndex(sq.getEnd());
 257           if (iend < startPosition || ist > endPosition)
 258           {
 259             // sequence not in region
 260             continue;
 261           }
 262           for (SequenceFeature sf : sfs)
 263           {
 264             // future functionality - featureType == null means mark columns
 265             // containing all displayed features
 266             if (sf != null && (featureType.equals(sf.getType())))
 267             {
 268               // optimisation - could consider 'spos,apos' like cursor argument
 269               // - findIndex wastes time by starting from first character and
 270               // counting
 271
 272               int sfStartCol = sq.findIndex(sf.getBegin());
 273               int sfEndCol = sq.findIndex(sf.getEnd());
 274
 275               if (sf.isContactFeature())
 276               {
 277                 /*
 278                  * 'contact' feature - check for 'start' or 'end'
 279                  * position within the selected region
 280                  */
 281                 if (sfStartCol >= startPosition
 282                         && sfStartCol <= endPosition)
 283                 {
 284                   bs.set(sfStartCol - 1);
 285                   sequenceHasFeature = true;
 286                 }
 287                 if (sfEndCol >= startPosition && sfEndCol <= endPosition)
 288                 {
 289                   bs.set(sfEndCol - 1);
 290                   sequenceHasFeature = true;
 291                 }
 292                 continue;
 293               }
 294
 295               /*
 296                * contiguous feature - select feature positions (if any)
 297                * within the selected region
 298                */
 299               if (sfStartCol > endPosition || sfEndCol < startPosition)
 300               {
 301                 // feature is outside selected region
 302                 continue;
 303               }
 304               sequenceHasFeature = true;
 305               if (sfStartCol < startPosition)
 306               {
 307                 sfStartCol = startPosition;
 308               }
 309               if (sfStartCol < ist)
 310               {
 311                 sfStartCol = ist;
 312               }
 313               if (sfEndCol > endPosition)
 314               {
 315                 sfEndCol = endPosition;
 316               }
 317               for (; sfStartCol <= sfEndCol; sfStartCol++)
 318               {
 319                 bs.set(sfStartCol - 1); // convert to base 0
 320               }
 321             }
 322           }
 323         }
 324
 325         if (sequenceHasFeature)
 326         {
 327           nseq++;
 328         }
 329       }
 330     }
 331     return nseq;
 332   }
 333
 334   @Override
 335   public void sortAlignmentByFeatureDensity(List<String> typ)
 336   {
 337     sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY);
 338   }
 339
 340   protected void sortBy(List<String> typ, String methodText,
 341           final String method)
 342   {
 343     FeatureRenderer fr = alignPanel.getFeatureRenderer();
 344     if (typ == null && fr != null)
 345     {
 346       typ = fr.getDisplayedFeatureTypes();
 347     }
 348     List<String> gps = null;
 349     if (fr != null)
 350     {
 351       gps = fr.getDisplayedFeatureGroups();
 352     }
 353     AlignmentI al = viewport.getAlignment();
 354
 355     int start, stop;
 356     SequenceGroup sg = viewport.getSelectionGroup();
 357     if (sg != null)
 358     {
 359       start = sg.getStartRes();
 360       stop = sg.getEndRes();
 361     }
 362     else
 363     {
 364       start = 0;
 365       stop = al.getWidth();
 366     }
 367     SequenceI[] oldOrder = al.getSequencesArray();
 368     AlignmentSorter.sortByFeature(typ, gps, start, stop, al, method);
 369     avcg.addHistoryItem(new OrderCommand(methodText, oldOrder, viewport
 370             .getAlignment()));
 371     alignPanel.paintAlignment(true);
 372
 373   }
 374
 375   @Override
 376   public void sortAlignmentByFeatureScore(List<String> typ)
 377   {
 378     sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE);
 379   }
 380
 381   @Override
 382   public boolean parseFeaturesFile(String file, DataSourceType protocol,
 383           boolean relaxedIdMatching)
 384   {
 385     boolean featuresFile = false;
 386     try
 387     {
 388       featuresFile = new FeaturesFile(false, file, protocol).parse(viewport
 389               .getAlignment().getDataset(), alignPanel.getFeatureRenderer()
 390               .getFeatureColours(), false, relaxedIdMatching);
 391     } catch (Exception ex)
 392     {
 393       ex.printStackTrace();
 394     }
 395
 396     if (featuresFile)
 397     {
 398       avcg.refreshFeatureUI(true);
 399       if (alignPanel.getFeatureRenderer() != null)
 400       {
 401         // update the min/max ranges where necessary
 402         alignPanel.getFeatureRenderer().findAllFeatures(true);
 403       }
 404       if (avcg.getFeatureSettingsUI() != null)
 405       {
 406         avcg.getFeatureSettingsUI().discoverAllFeatureData();
 407       }
 408       alignPanel.paintAlignment(true);
 409     }
 410
 411     return featuresFile;
 412
 413   }
 414
 415   @Override
 416   public boolean markHighlightedColumns(boolean invert,
 417           boolean extendCurrent, boolean toggle)
 418   {
 419     if (!viewport.hasSearchResults())
 420     {
 421       // do nothing if no selection exists
 422       return false;
 423     }
 424     // JBPNote this routine could also mark rows, not just columns.
 425     BitSet bs = new BitSet();
 426     SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null || extendCurrent) ? viewport
 427             .getAlignment() : viewport.getSelectionGroup();
 428
 429     // this could be a lambda... - the remains of the method is boilerplate,
 430     // except for the different messages for reporting selection.
 431     int nseq = viewport.getSearchResults().markColumns(sqcol, bs);
 432
 433     ColumnSelection cs = viewport.getColumnSelection();
 434     if (cs == null)
 435     {
 436       cs = new ColumnSelection();
 437     }
 438
 439     if (bs.cardinality() > 0 || invert)
 440     {
 441       boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
 442               sqcol.getEndRes(), invert, extendCurrent, toggle);
 443       if (changed)
 444       {
 445         viewport.setColumnSelection(cs);
 446         alignPanel.paintAlignment(true);
 447         int columnCount = invert ? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
 448                 - bs.cardinality()
 449                 : bs.cardinality();
 450         avcg.setStatus(MessageManager.formatMessage(
 451                 "label.view_controller_toggled_marked",
 452                 new String[] {
 453                     toggle ? MessageManager.getString("label.toggled")
 454                             : MessageManager.getString("label.marked"),
 455                     String.valueOf(columnCount),
 456                     invert ? MessageManager
 457                             .getString("label.not_containing")
 458                             : MessageManager.getString("label.containing"),
 459                     "Highlight", Integer.valueOf(nseq).toString() }));
 460         return true;
 461       }
 462     }
 463     else
 464     {
 465       avcg.setStatus(MessageManager
 466               .formatMessage("No highlighted regions marked"));
 467       if (!extendCurrent)
 468       {
 469         cs.clear();
 470         alignPanel.paintAlignment(true);
 471       }
 472     }
 473     return false;
 474   }
 475
 476 }