src/jalview/ext/archaeopteryx/JalviewBinding.java

   1 package jalview.ext.archaeopteryx;
   2
   3 import jalview.analysis.AlignmentSorter;
   4 import jalview.analysis.Conservation;
   5 import jalview.api.AlignViewportI;
   6 import jalview.commands.CommandI;
   7 import jalview.commands.OrderCommand;
   8 import jalview.datamodel.ColumnSelection;
   9 import jalview.datamodel.HiddenColumns;
  10 import jalview.datamodel.SequenceGroup;
  11 import jalview.datamodel.SequenceI;
  12 import jalview.ext.treeviewer.TreeFrameI;
  13 import jalview.ext.treeviewer.TreeI;
  14 import jalview.ext.treeviewer.TreeNodeI;
  15 import jalview.ext.treeviewer.TreePanelI;
  16 import jalview.ext.treeviewer.TreeViewerBindingI;
  17 import jalview.ext.treeviewer.TreeViewerUtils;
  18 import jalview.ext.treeviewer.LoadedTreeSequenceAssociation;
  19 import jalview.gui.AlignViewport;
  20 import jalview.gui.AlignmentPanel;
  21 import jalview.gui.Desktop;
  22 import jalview.gui.JvOptionPane;
  23 import jalview.gui.PaintRefresher;
  24 import jalview.schemes.ColourSchemeI;
  25 import jalview.schemes.ColourSchemeProperty;
  26 import jalview.schemes.UserColourScheme;
  27 import jalview.structure.SelectionSource;
  28 import jalview.structure.StructureSelectionManager;
  29 import jalview.util.MappingUtils;
  30 import jalview.util.MessageManager;
  31 import jalview.viewmodel.AlignmentViewport;
  32
  33 import java.awt.Color;
  34 import java.awt.Rectangle;
  35 import java.awt.event.ActionEvent;
  36 import java.awt.event.InputEvent;
  37 import java.awt.event.MouseEvent;
  38 import java.util.ArrayList;
  39 import java.util.HashSet;
  40 import java.util.List;
  41 import java.util.Map;
  42 import java.util.Set;
  43
  44 import javax.swing.SwingUtilities;
  45 import javax.swing.event.InternalFrameAdapter;
  46 import javax.swing.event.InternalFrameEvent;
  47
  48 /**
  49  * Class for binding the Archaeopteryx tree viewer to the Jalview alignment that
  50  * it originates from, meaning that selecting sequences in the tree viewer also
  51  * selects them in the alignment view and vice versa.
  52  *
  53  * @author kjvanderheide
  54  *
  55  */
  56 public final class JalviewBinding
  57         implements TreeViewerBindingI
  58 {
  59   private final TreeFrameI aptxFrame;
  60
  61   private TreePanelI treeView;
  62
  63   private AlignmentViewport parentAvport;
  64
  65   private final StructureSelectionManager ssm;
  66
  67   private AlignmentPanel[] associatedPanels;
  68
  69   private Map<SequenceI, TreeNodeI> sequencesBoundToNodes;
  70
  71   private Map<TreeNodeI, SequenceI> nodesBoundToSequences;
  72
  73   private float rootX;
  74
  75   private float furthestNodeX;
  76
  77   private int nrTreeGroups = 0;
  78
  79   private boolean applyToAllViews = false;
  80
  81   /**
  82    *
  83    * @param archaeopteryx
  84    *
  85    * @param jalviewAlignmentViewport
  86    *          alignment viewport from which the tree was calculated.
  87    *
  88    * @param alignMappedToNodes
  89    *          map with sequences used to calculate the tree and matching tree
  90    *          nodes as key, value pair respectively.
  91    *
  92    * @param nodesMappedToAlign
  93    *          map with tree nodes and matching sequences used to calculate the
  94    *          tree as key, value pair respectively.
  95    */
  96   public JalviewBinding(final TreeFrameI archaeopteryx,
  97           final AlignmentViewport jalviewAlignmentViewport,
  98           final Map<SequenceI, TreeNodeI> alignMappedToNodes,
  99           final Map<TreeNodeI, SequenceI> nodesMappedToAlign)
 100   {
 101
 102     if (archaeopteryx.getNumberOfTrees() > 1)
 103     {
 104       JvOptionPane.showMessageDialog(Desktop.desktop,
 105               MessageManager.getString("label.tabs_detected_archaeopteryx"),
 106               MessageManager.getString("label.problem_reading_tree_file"),
 107               JvOptionPane.WARNING_MESSAGE);
 108
 109     }
 110
 111     // deal with/prohibit null values here as that will cause problems
 112     aptxFrame = archaeopteryx;
 113     parentAvport = jalviewAlignmentViewport;
 114     sequencesBoundToNodes = alignMappedToNodes;
 115     nodesBoundToSequences = nodesMappedToAlign;
 116
 117     treeView = archaeopteryx.getTreePanel();
 118     ssm = parentAvport.getStructureSelectionManager();
 119
 120     ssm.addSelectionListener(this);
 121     treeView.addMouseListener(this);
 122     treeView.registerWithPaintRefresher(
 123             parentAvport.getSequenceSetId());
 124     associatedPanels = PaintRefresher
 125             .getAssociatedPanels(parentAvport.getSequenceSetId());
 126
 127     aptxFrame.addFrameListener(new InternalFrameAdapter()
 128     {
 129
 130       @Override
 131       public void internalFrameClosed(InternalFrameEvent e)
 132       {
 133         TreeViewerUtils.getActiveTreeViews().remove(aptxFrame);
 134         ssm.removeSelectionListener(JalviewBinding.this);
 135       }
 136
 137     });
 138
 139     // treeTabs.addChangeListener(new ChangeListener()
 140     // {
 141     //
 142     // @Override
 143     // public void stateChanged(ChangeEvent e)
 144     // {
 145     //
 146     // SwingUtilities.invokeLater(new Runnable()
 147     // {
 148     //
 149     // @Override
 150     // /**
 151     // * Resend the selection to the tree view when tabs get switched, this
 152     // * has to be buried in invokeLater as Forester first resets the tree
 153     // * view on switching tabs, without invokeLater this would get called
 154     // * before Forester resets which would nullify the selection.
 155     // */
 156     // public void run()
 157     // {
 158     // treeView = archaeopteryx.getMainPanel().getCurrentTreePanel();
 159     // parentAvport.sendSelection();
 160     // // PaintRefresher.Refresh(treeView,
 161     // // parentAvport.getSequenceSetId());
 162     //
 163     // }
 164     // });
 165     //
 166     // }
 167     //
 168     // });
 169
 170   }
 171
 172   @Override
 173   public void actionPerformed(ActionEvent e)
 174   {
 175     // reset hidden sequences first
 176     parentAvport.showAllHiddenSeqs();
 177
 178     if (treeView.showingSubTree())
 179     {
 180     LoadedTreeSequenceAssociation bindAptxNodes = new LoadedTreeSequenceAssociation(
 181             parentAvport.getAlignment().getSequencesArray(),
 182               treeView.getTree());
 183     bindAptxNodes.associateLeavesToSequences();
 184     sequencesBoundToNodes = bindAptxNodes.getAlignmentWithNodes();
 185     nodesBoundToSequences = bindAptxNodes.getNodesWithAlignment();
 186     TreeViewerUtils.associateNodesWithJalviewSequences(aptxFrame, parentAvport,
 187             sequencesBoundToNodes, nodesBoundToSequences);
 188
 189
 190     for (SequenceI seq : parentAvport.getAlignment().getSequencesArray())
 191     {
 192       if (!sequencesBoundToNodes.containsKey(seq))
 193       {
 194         parentAvport.hideSequence(new SequenceI[] { seq });
 195       }
 196       }
 197     }
 198
 199     else
 200     {
 201
 202       Rectangle visibleView = treeView.getVisibleArea();
 203
 204       for (TreeNodeI node : treeView.getTree().getRoot()
 205               .getAllDescendants())
 206       {
 207         if (!(node.getXcoord() > visibleView.getMinX()
 208                 && node.getXcoord() < visibleView.getMaxX()
 209                 && node.getYcoord() > visibleView.getMinY()
 210                 && node.getYcoord() < visibleView.getMaxY()))
 211         {
 212           parentAvport
 213                   .hideSequence(new SequenceI[]
 214                   { nodesBoundToSequences.get(node) });
 215         }
 216       }
 217
 218     }
 219
 220
 221
 222   }
 223
 224   @Override
 225   public void mouseClicked(MouseEvent e)
 226   {
 227     SwingUtilities.invokeLater(new Runnable() {
 228
 229       @Override
 230       /**
 231        * invokeLater so that this always runs after Forester's mouseClicked
 232        */
 233       public void run()
 234       {
 235         final TreeNodeI node = treeView.findNode(e.getX(),
 236                 e.getY());
 237         if (node != null)
 238         {
 239           if ((e.getModifiers() & InputEvent.SHIFT_MASK) == 0) // clear previous
 240           // selection if shift
 241           // IS NOT pressed
 242           {
 243             parentAvport.setSelectionGroup(null);
 244
 245           }
 246           showNodeSelectionOnAlign(node);
 247         }
 248         else
 249         {
 250
 251           partitionTree(e.getX());
 252       }
 253         treeView.notifyPaintRefresher(parentAvport.getSequenceSetId(),
 254                 false, false);
 255         treeView.repaint();
 256
 257
 258
 259       }
 260     });
 261
 262
 263   }
 264
 265   @Override
 266   public void mousePressed(final MouseEvent e)
 267   {
 268
 269   }
 270   @Override
 271   public void mouseReleased(MouseEvent e)
 272   {
 273   }
 274
 275   @Override
 276   public void mouseEntered(MouseEvent e)
 277   {
 278   }
 279
 280   @Override
 281   public void mouseExited(MouseEvent e)
 282   {
 283   }
 284
 285
 286   @Override
 287   public void selection(final SequenceGroup seqsel,
 288           final ColumnSelection colsel, final HiddenColumns hidden,
 289           final SelectionSource source)
 290   {
 291     if (source == parentAvport) // check if source is alignment from where the
 292     // tree originates
 293     {
 294       treeView.setMatchingNodes(
 295               new HashSet<Long>(seqsel.getSequences().size()));
 296
 297
 298       for (SequenceI selectedSequence : seqsel.getSequences())
 299       {
 300         TreeNodeI matchingNode = sequencesBoundToNodes
 301                 .get(selectedSequence);
 302         if (matchingNode != null)
 303         {
 304           treeView.getMatchingNodes().add(matchingNode.getId());
 305
 306
 307           // if (!matchingNode.getBranchData().isHasBranchColor())
 308           // {
 309           // // Color foundNodesColour = treeView.getTreeColorSet()
 310           // // .getFoundColor0();
 311           // // matchingNode.getBranchData()
 312           // // .setBranchColor(new BranchColor(foundNodesColour));
 313           //
 314           // }
 315
 316         }
 317
 318       }
 319
 320       treeView.repaint();
 321     }
 322
 323
 324   }
 325
 326   /**
 327    * Partially refactored from TreeCanvas
 328    */
 329   public void partitionTree(final int x)
 330   {
 331     TreeI tree = treeView.getTree();
 332
 333     if (!tree.isEmpty())
 334     {
 335       // should be calculated on each partition as the tree can theoretically
 336       // change in the meantime
 337       TreeNodeI furthestNode = tree.getFurthestNode();
 338       furthestNodeX = furthestNode.getXcoord();
 339       rootX = tree.getRoot().getXcoord();
 340
 341       // don't bother if 0 distance tree or clicked x lies outside of tree
 342       if (furthestNodeX != rootX && !(x > furthestNodeX))
 343       {
 344         float threshold = (x - rootX) / (furthestNodeX - rootX);
 345         List<TreeNodeI> foundNodes = getNodesAboveThreshold(
 346                 threshold,
 347                 tree.getRoot());
 348
 349       }
 350     }
 351
 352
 353   }
 354
 355   public List<TreeNodeI> getNodesAboveThreshold(double threshold,
 356           TreeNodeI node)
 357   {
 358
 359     List<TreeNodeI> nodesAboveThreshold = new ArrayList<>();
 360
 361     parentAvport.setSelectionGroup(null);
 362     parentAvport.getAlignment().deleteAllGroups();
 363     parentAvport.clearSequenceColours();
 364     if (parentAvport.getCodingComplement() != null)
 365     {
 366       parentAvport.getCodingComplement().setSelectionGroup(null);
 367       parentAvport.getCodingComplement().getAlignment().deleteAllGroups();
 368       parentAvport.getCodingComplement().clearSequenceColours();
 369     }
 370
 371
 372     colourNodesAboveThreshold(nodesAboveThreshold, threshold,
 373             node);
 374     return nodesAboveThreshold;
 375
 376   }
 377
 378   /**
 379    * Partially refactored from TreeCanvas colourGroups (can be made nicer).
 380    *
 381    * @param nodeList
 382    * @param threshold
 383    * @param treeLength
 384    * @param node
 385    * @return
 386    */
 387   private List<TreeNodeI> colourNodesAboveThreshold(
 388           List<TreeNodeI> nodeList, double threshold,
 389           TreeNodeI node)
 390   {
 391
 392     for (TreeNodeI childNode : node.getDirectChildren())
 393     {
 394       childNode.setBranchColor(Color.black);
 395       float nodeCutoff = (childNode.getXcoord() - rootX)
 396               / (furthestNodeX - rootX);
 397
 398       if (nodeCutoff > threshold)
 399       {
 400         nodeList.add(childNode);
 401
 402         Color randomColour = new Color((int) (Math.random() * 255),
 403                 (int) (Math.random() * 255), (int) (Math.random() * 255));
 404         childNode.setBranchColor(randomColour);
 405
 406         List<SequenceI> groupSeqs = new ArrayList<>();
 407         SequenceI seq = nodesBoundToSequences.get(childNode);
 408         if (seq != null)
 409         {
 410           groupSeqs.add(seq);
 411           parentAvport.setSequenceColour(seq, randomColour);
 412         }
 413
 414         List<TreeNodeI> descendantNodes = childNode
 415                 .getAllDescendants();
 416         // .forEach instead?
 417         for (TreeNodeI descNode : descendantNodes)
 418         {
 419           seq = nodesBoundToSequences.get(descNode);
 420           if (seq != null)
 421           {
 422             groupSeqs.add(seq);
 423             parentAvport.setSequenceColour(seq, randomColour);
 424           }
 425
 426           descNode.setBranchColor(randomColour);
 427         }
 428
 429         if (groupSeqs != null)
 430         {
 431           nrTreeGroups++;
 432           groupThresholdSequences(groupSeqs, randomColour);
 433         }}
 434
 435       else
 436       {
 437         colourNodesAboveThreshold(nodeList, threshold, childNode);
 438       }
 439     }
 440
 441
 442         for (AlignmentPanel associatedPanel : associatedPanels) {
 443
 444         associatedPanel.updateAnnotation();
 445
 446         final AlignViewportI codingComplement = associatedPanel.getAlignViewport()
 447                 .getCodingComplement();
 448         if (codingComplement != null)
 449         {
 450           // GROSS
 451           ((AlignViewport) codingComplement).getAlignPanel()
 452                   .updateAnnotation();
 453         }
 454       }
 455
 456
 457     return nodeList;
 458   }
 459
 460   public void groupThresholdSequences(List<SequenceI> groupedSeqs,
 461           Color groupColour)
 462   {
 463     SequenceGroup treeGroup = new SequenceGroup(groupedSeqs, null, null,
 464             true, true, false, 0,
 465             parentAvport.getAlignment().getWidth() - 1);
 466
 467     ColourSchemeI cs = null;
 468     if (parentAvport.getGlobalColourScheme() != null)
 469     {
 470       if (parentAvport.getGlobalColourScheme() instanceof UserColourScheme)
 471       {
 472         cs = new UserColourScheme(
 473                 ((UserColourScheme) parentAvport.getGlobalColourScheme())
 474                         .getColours());
 475       }
 476       else
 477       {
 478         cs = ColourSchemeProperty.getColourScheme(treeGroup,
 479                 ColourSchemeProperty.getColourName(
 480                         parentAvport.getGlobalColourScheme()));
 481       }
 482
 483     }
 484     treeGroup.setColourScheme(cs);
 485     treeGroup.getGroupColourScheme().setThreshold(
 486             parentAvport.getResidueShading().getThreshold(),
 487             parentAvport.isIgnoreGapsConsensus());
 488
 489     treeGroup.setName("Tree Group " + nrTreeGroups);
 490     treeGroup.setIdColour(groupColour);
 491
 492     for (AlignmentPanel associatedPanel : associatedPanels)
 493     {
 494       AlignViewportI altViewport = associatedPanel
 495               .getAlignViewport();
 496
 497       if (altViewport.getGlobalColourScheme() != null
 498               && altViewport.getResidueShading()
 499                       .conservationApplied())
 500       {
 501         Conservation conserv = new Conservation(treeGroup.getName(),
 502                 treeGroup.getSequences(null), treeGroup.getStartRes(),
 503                 treeGroup.getEndRes());
 504         conserv.calculate();
 505         conserv.verdict(false, altViewport.getConsPercGaps());
 506         treeGroup.getGroupColourScheme().setConservation(conserv);
 507       }
 508
 509       altViewport.getAlignment().addGroup(treeGroup);
 510       // TODO can we push all of the below into AlignViewportI?
 511       final AlignViewportI codingComplement = altViewport
 512               .getCodingComplement();
 513       if (codingComplement != null)
 514       {
 515         SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(treeGroup,
 516                 parentAvport, codingComplement);
 517         if (mappedGroup.getSequences().size() > 0)
 518         {
 519           codingComplement.getAlignment().addGroup(mappedGroup);
 520           for (SequenceI seq : mappedGroup.getSequences())
 521           {
 522             codingComplement.setSequenceColour(seq, groupColour.brighter());
 523           }
 524         }
 525       }
 526
 527     }
 528
 529   }
 530
 531   /**
 532    * may or may not need an extra repaint on the alignment view (check what kira
 533    * does)
 534    */
 535   @Override
 536   public void showNodeSelectionOnAlign(final TreeNodeI node)
 537   {
 538
 539       if (node.isInternal())
 540       {
 541         showMatchingChildSequences(node);
 542       }
 543
 544       else
 545       {
 546         showMatchingSequence(node);
 547       }
 548
 549
 550     }
 551
 552
 553
 554
 555
 556   @Override
 557   public void showMatchingSequence(final TreeNodeI nodeToMatch)
 558   {
 559     SequenceI matchingSequence = nodesBoundToSequences.get(nodeToMatch);
 560     if (matchingSequence != null)
 561     {
 562       long nodeId = nodeToMatch.getId();
 563       addOrRemoveInSet(treeView.getMatchingNodes(), nodeId);
 564       treeSelectionChanged(matchingSequence);
 565       parentAvport.sendSelection();
 566
 567     }
 568   }
 569
 570   @Override
 571   public void showMatchingChildSequences(final TreeNodeI parentNode)
 572   {
 573     // redundancy here, Forester already iterates through tree to get all
 574     // descendants
 575     List<TreeNodeI> childNodes = parentNode.getAllDescendants();
 576
 577
 578     for (TreeNodeI childNode : childNodes)
 579     {
 580       // childNode.getBranchData().setBranchColor(new BranchColor(Color.BLUE));
 581
 582       SequenceI matchingSequence = nodesBoundToSequences.get(childNode);
 583       if (matchingSequence != null)
 584       {
 585         long nodeId = childNode.getId();
 586         addOrRemoveInSet(treeView.getMatchingNodes(), nodeId);
 587
 588         treeSelectionChanged(matchingSequence);
 589
 590       }
 591
 592     }
 593     parentAvport.sendSelection();
 594
 595
 596   }
 597
 598   /**
 599    * Refactored from TreeCanvas.
 600    *
 601    * @param sequence
 602    *          of the node selected in the tree viewer.
 603    */
 604   @Override
 605   public void treeSelectionChanged(final SequenceI sequence)
 606   {
 607     if (!parentAvport.isClosed()) // alignment view could be closed
 608     {
 609       SequenceGroup selected = parentAvport.getSelectionGroup();
 610
 611       if (selected == null)
 612       {
 613         selected = new SequenceGroup();
 614         parentAvport.setSelectionGroup(selected);
 615       }
 616
 617       selected.setEndRes(parentAvport.getAlignment().getWidth() - 1);
 618         selected.addOrRemove(sequence, true);
 619     }
 620
 621   }
 622
 623   @Override
 624   public void sortByTree_actionPerformed()// modify for Aptx
 625   {
 626
 627     // if (treeCanvas.applyToAllViews)
 628     // {
 629     // final ArrayList<CommandI> commands = new ArrayList<>();
 630     // for (AlignmentPanel ap : PaintRefresher
 631     // .getAssociatedPanels(parentAvport.getSequenceSetId()))
 632     // {
 633     // commands.add(sortAlignmentIn(ap.av.getAlignPanel()));
 634     // }
 635     // parentAvport.getAlignPanel().alignFrame.addHistoryItem(new CommandI()
 636     // {
 637     //
 638     // @Override
 639     // public void undoCommand(AlignmentI[] views)
 640     // {
 641     // for (CommandI tsort : commands)
 642     // {
 643     // tsort.undoCommand(views);
 644     // }
 645     // }
 646     //
 647     // @Override
 648     // public int getSize()
 649     // {
 650     // return commands.size();
 651     // }
 652     //
 653     // @Override
 654     // public String getDescription()
 655     // {
 656     // return "Tree Sort (many views)";
 657     // }
 658     //
 659     // @Override
 660     // public void doCommand(AlignmentI[] views)
 661     // {
 662     //
 663     // for (CommandI tsort : commands)
 664     // {
 665     // tsort.doCommand(views);
 666     // }
 667     // }
 668     // });
 669     // for (AlignmentPanel ap : PaintRefresher
 670     // .getAssociatedPanels(av.getSequenceSetId()))
 671     // {
 672     // // ensure all the alignFrames refresh their GI after adding an undo item
 673     // ap.alignFrame.updateEditMenuBar();
 674     // }
 675     // }
 676     // else
 677     // {
 678     // treeCanvas.ap.alignFrame
 679     // .addHistoryItem(sortAlignmentIn(treeCanvas.ap));
 680     // }
 681
 682   }
 683
 684   @Override
 685   public CommandI sortAlignmentIn(AlignmentPanel ap)
 686   {
 687     // TODO: move to alignment view controller
 688
 689     AlignmentViewport viewport = ap.av;
 690     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
 691     try
 692     {
 693     AlignmentSorter.sortByTree(viewport.getAlignment(),
 694             nodesBoundToSequences,
 695               treeView.getTree());
 696       CommandI undo;
 697       undo = new OrderCommand("Tree Sort", oldOrder,
 698               viewport.getAlignment());
 699
 700       ap.paintAlignment(true, false);
 701       return undo;
 702
 703     } catch (Exception e)
 704     {
 705       System.err.println(e.getMessage());
 706     }
 707     return null;
 708
 709   }
 710
 711
 712
 713   /**
 714    * TO BE MOVED
 715    *
 716    * @param set
 717    * @param objectToCheck
 718    */
 719   public static <E> void addOrRemoveInSet(Set<E> set, E objectToCheck)
 720   {
 721     if (set.contains(objectToCheck))
 722     {
 723       set.remove(objectToCheck);
 724     }
 725     else
 726     {
 727       set.add(objectToCheck);
 728     }
 729
 730   }
 731
 732   public AlignmentViewport getParentAvport()
 733   {
 734     return parentAvport;
 735   }
 736
 737   public void setParentAvport(final AlignmentViewport parentAvport)
 738   {
 739     this.parentAvport = parentAvport;
 740   }
 741
 742   public AlignmentPanel[] getAssociatedPanels()
 743   {
 744     return associatedPanels;
 745   }
 746
 747   public void setAssociatedPanels(AlignmentPanel[] associatedPanels)
 748   {
 749     this.associatedPanels = associatedPanels;
 750   }
 751
 752 }
 753
 754
 755