Shear UI

empress/support_files/css/empress.css

@@ -585,6 +585,13 @@ p.side-header button:hover,
     white-space: nowrap;
 }
 
+.shear-layer-legend div {
+    max-height: 15em;
+    /* The side panel width is 450px */
+    max-width: 430px;
+    overflow: auto;
+}
+
 .barplot-layer-legend {
     max-height: 15em;
     /* The side panel width is 450px */

empress/support_files/js/biom-table.js

@@ -86,6 +86,13 @@ define(["underscore", "util"], function (_, util) {
         this._tbl = tbl;
         this._smCols = smCols;
         this._sm = sm;
+
+        /**
+         * A set of feature ids to ignore. This is whenever the tree is sheared
+         * and will contain the features id (tips) that were removed.
+         * @ type {Set}
+         */
+        this.ignorefIdx = new Set();
     }
 
     /**
@@ -278,7 +285,9 @@ define(["underscore", "util"], function (_, util) {
         var cVal;
         var addSampleFeatures = function (sIdx, cVal) {
             _.each(scope._tbl[sIdx], function (fIdx) {
-                valueToFeatureIdxs[cVal].add(fIdx);
+                if (!scope.ignorefIdx.has(fIdx)) {
+                    valueToFeatureIdxs[cVal].add(fIdx);
+                }
             });
         };
         // For each sample...
@@ -582,6 +591,10 @@ define(["underscore", "util"], function (_, util) {
         var fID2Freqs = {};
         var totalSampleCount;
         _.each(this._fIDs, function (fID, fIdx) {
+            // we dont want to consider features that have been marked as ignore
+            if (scope.ignorefIdx.has(fIdx)) {
+                return;
+            }
             totalSampleCount = fIdx2SampleCt[fIdx];
             fID2Freqs[fID] = {};
             _.each(fIdx2Counts[fIdx], function (count, smValIdx) {
@@ -591,8 +604,25 @@ define(["underscore", "util"], function (_, util) {
                 }
             });
         });
+
         return fID2Freqs;
     };
 
+    /**
+     * Set which features to ignore. Features in this set will not be
+     * considered in funcitons such as getObsBy() or getFrequencyMap()
+     *
+     * @param {Set} nodes A set of feature ids to ignore
+     */
+    BIOMTable.prototype.setIngnoreNodes = function (nodes) {
+        var scope = this;
+
+        // convert feature ids to feature indices
+        var nodeIdx = _.map([...nodes], (fId) => {
+            return scope._getFeatureIndexFromID(fId);
+        });
+        this.ignorefIdx = new Set(nodeIdx);
+    };
+
     return BIOMTable;
 });

empress/support_files/js/bp-tree.js

@@ -131,7 +131,8 @@ define(["ByteArray", "underscore"], function (ByteArray, _) {
          * performance boost
          */
         var eCache = [];
-        for (var i = 0; i < this.b_.length; i++) {
+        var i;
+        for (i = 0; i < this.b_.length; i++) {
             eCache.push(2 * this.r1Cache_[i] - i - 1);
         }
         this.eCache_ = new Uint32Array(eCache);
@@ -190,6 +191,33 @@ define(["ByteArray", "underscore"], function (ByteArray, _) {
          * that have the same name.
          */
         this._nameToNodes = {};
+
+        /**
+         * @type {Array}
+         * @private
+         * Cache Parent nodes. This will help speed up a lot of methods that
+         * make calls to parent.
+         */
+        this._pCache = [];
+        var pStack = [];
+        for (i = 0; i < this.b_.length - 1; i++) {
+            if (this.b_[i] === 1) {
+                if (pStack.length === 0) {
+                    pStack.push(i);
+                    this._pCache[i] = 0;
+                } else if (this.b_[i + 1] === 1) {
+                    this._pCache[i] = pStack[pStack.length - 1];
+                    pStack.push(i);
+                } else if (this.b_[i + 1] === 0) {
+                    this._pCache[i] = pStack[pStack.length - 1];
+                }
+            } else if (this.b_[i] === 0) {
+                this._pCache[i] = pStack[pStack.length - 1];
+                if (this.b_[i + 1] === 0) {
+                    pStack.pop();
+                }
+            }
+        }
     }
 
     /**
@@ -452,7 +480,7 @@ define(["ByteArray", "underscore"], function (ByteArray, _) {
             return -1;
         }
 
-        return this.enclose(i);
+        return this._pCache[i];
     };
 
     /**
@@ -702,7 +730,9 @@ define(["ByteArray", "underscore"], function (ByteArray, _) {
         // find first and last preorder positions of the subtree spanned
         // by the current internal node
         var n = this.postorderselect(nodeKey);
-        if (this.isleaf(n)) {
+
+        // check for root to account for cases when all tips have been sheared
+        if (this.isleaf(n) && nodeKey !== this.postorder(this.root())) {
             throw "Error: " + nodeKey + " is a tip!";
         }
         var start = this.preorder(this.fchild(n));
@@ -984,41 +1014,58 @@ define(["ByteArray", "underscore"], function (ByteArray, _) {
      *                  convert the original postorder positions to the sheared
      *                  tree postorder positions ("newToOld") and vice-versa ("oldToNew").
      */
-    BPTree.prototype.shear = function (keepTips) {
+    BPTree.prototype.shear = function (removeTips) {
         // closure
         var scope = this;
 
-        // create new names and lengths array
-        var names = [null];
-        var lengths = [null];
-
         // create new bit array
-        var mask = [];
+        var mask = _.clone(this.b_);
 
-        // function to that will set open/close bits for a node
-        var set_bits = (node) => {
-            mask[node] = 1;
-            mask[scope.close(node)] = 0;
-        };
+        var i, node;
 
-        // set root open/close bits
-        set_bits(this.root());
+        // remove tips
+        for (i of removeTips) {
+            node = this.postorderselect(i);
+            mask[node] = undefined;
+            mask[node + 1] = undefined;
+        }
 
-        // iterate over bp tree in post order and add all tips that are in
-        // keepTips plus their ancestors
-        var i;
-        for (i = 1; i <= this.size; i++) {
-            var node = this.postorderselect(i);
-            var name = this.name(node);
-            if (this.isleaf(node) && keepTips.has(name)) {
-                // set open/close bits for tip
-                set_bits(node);
-
-                // set open/close bits for tips ancestors
-                var parent = this.parent(node);
-                while (parent !== this.root() || mask[parent] !== 1) {
-                    set_bits(parent);
-                    parent = this.parent(parent);
+        // remove internal
+        var nodeStack = [];
+        for (i = mask.length - 1; i > 0; i--) {
+            if (mask[i] === 0) {
+                // close parentheses
+                if (mask[i - 1] === 0) {
+                    // close parentheses represents internal node
+                    nodeStack.push([i, null]);
+                } else if (mask[i - 1] === 1) {
+                    // close parentheses represents non-removed tip
+                    // thus we mark it as false so it is not removed
+                    nodeStack.push([i, false]);
+                } else if (mask[i - 1] === undefined) {
+                    // close paretheses represents an internal node
+                    // with at least one removed tip so we temporarly mark it
+                    // as true to remove
+                    nodeStack.push([i, true]);
+                }
+            } else if (mask[i] === 1) {
+                //open parentheses
+                node = nodeStack.pop();
+                if (node[1] === true) {
+                    // remove internal node
+                    mask[i] = undefined;
+                    mask[node[0]] = undefined;
+                } else if (node[1] === false) {
+                    // need explicitly check false since it can be null
+                    // if node[1] is false that means it contains a tip and thus
+                    // we need to mark its parent as false so it is not removed
+                    nodeStack[nodeStack.length - 1][1] = false;
+                }
+
+                if (nodeStack[nodeStack.length - 1][1] === null) {
+                    // if null then we set its remove status to whatever node
+                    // was
+                    nodeStack[nodeStack.length - 1][1] = node[1];
                 }
             }
         }
@@ -1027,14 +1074,16 @@ define(["ByteArray", "underscore"], function (ByteArray, _) {
         var shearedToFull = new Map();
         var fullToSheared = new Map();
         var postorderPos = 1;
+        // create new names and lengths array
+        var names = [null];
+        var lengths = [null];
         for (i = 0; i < mask.length; i++) {
             if (mask[i] !== undefined) {
                 newBitArray.push(mask[i]);
             }
 
             // get name and length of node
             // Note: names and lengths of nodes are stored in postorder
-
             if (mask[i] === 0) {
                 names.push(this.name(i));
                 lengths.push(this.length(i));
@@ -1043,6 +1092,7 @@ define(["ByteArray", "underscore"], function (ByteArray, _) {
                 postorderPos += 1;
             }
         }
+
         return {
             shearedToFull: shearedToFull,
             fullToSheared: fullToSheared,

empress/support_files/js/canvas-events.js

@@ -164,7 +164,9 @@ define(["underscore", "glMatrix", "SelectedNodeMenu"], function (
 
                 // Go through all the nodes in the tree and find the node
                 // closest to the (x, y) point that was clicked
-                for (var node = 1; node <= empress._tree.size; node++) {
+                for (var node of empress._tree.postorderTraversal(
+                    (includeRoot = true)
+                )) {
                     if (!empress.getNodeInfo(node, "visible")) continue;
                     var nodeX = empress.getX(node);
                     var nodeY = empress.getY(node);

empress/support_files/js/drawer.js

@@ -526,6 +526,8 @@ define(["underscore", "glMatrix", "Camera", "Colorer"], function (
      * @param{Number} zoomAmount The amout to zoom in or out.
      */
     Drawer.prototype.zoom = function (x, y, zoomIn, zoomAmount = this.scaleBy) {
+        // zoomAmount can be zero if all tips in the tree were sheared.
+        if (zoomAmount === 0) zoomAmount = this.scaleBy;
         var zoomAt = gl.vec4.fromValues(x, y, 0, 1);
         // move tree
         var transVec = gl.vec3.create();