This method is called to remove an edge through the IEdgeRemover
776013
private IEdge removeEdgeOnVertexDelete(UUID edgeId) throws BitsyException {
        // This is called from remove on adjMap, which means that the edge was added in this Tx
        BitsyEdge edge = changedEdges.remove(edgeId);
        
        // Only an edge that is present in this Tx can be removed by the IEdgeRemover
        assert (edge != null);
        
        return edge;
    }
1350151
function(border){
		var isset = this.isedgevalidbylinkobj(border);
		if(isset===this.isedgeexistsbylinkobj(border)){ return;}

		if(!!this.incdecBorderCount){
			this.incdecBorderCount(border, !isset);
		}

		if(isset){ this.addEdgeBySeparator(border);}
		else     { this.removeEdgeBySeparator(border);}
	}
647685
function removeEdge(u, v){
    if(edges[u]){
      edges[u] = adjacent(u).filter(function (_v){
        return _v !== v;
      });
    }
    return graph;
  }
448244
public void clearShowing() {

        m_showing = false;
        if (m_toolTip != null) {
            m_toolTip.removeFromParent();
            m_toolTip = null;
        }
        if (m_moveHandlerRegistration != null) {
            m_moveHandlerRegistration.removeHandler();
            m_moveHandlerRegistration = null;
        }
        if (m_outHandlerRegistration != null) {
            m_outHandlerRegistration.removeHandler();
            m_outHandlerRegistration = null;
        }
        m_removeTimer = null;
    }
389384
function _handleDeleteFilter(e) {
        // Remove the filter set from the preferences and
        // clear the active filter set index from view state.
        var filterSets        = PreferencesManager.get("fileFilters") || [],
            activeFilterIndex = PreferencesManager.getViewState("activeFileFilter"),
            filterIndex       = $(e.target).parent().data("index") - FIRST_FILTER_INDEX;

        // Don't let the click bubble upward.
        e.stopPropagation();

        filterSets.splice(filterIndex, 1);
        PreferencesManager.set("fileFilters", filterSets);

        if (activeFilterIndex === filterIndex) {
            // Removing the active filter, so clear the active filter
            // both in the view state.
            setActiveFilter(null);
        } else if (activeFilterIndex > filterIndex) {
            // Adjust the active filter index after the removal of a filter set before it.
            --activeFilterIndex;
            setActiveFilter(filterSets[activeFilterIndex], activeFilterIndex);
        }

        _updatePicker();
        _doPopulate();
        _picker.refresh();
    }
1309335
function () {
            _this15.el.style.display = 'none';
            _this15.$overlay.remove();

            // Call onCloseEnd callback
            if (typeof _this15.options.onCloseEnd === 'function') {
              _this15.options.onCloseEnd.call(_this15, _this15.el);
            }
          }
1047844
def suppress_deg_one_node(self, to_par_edge, nd_id, to_child_edge):
        """"""
        # circumvent the node with nd_id
        to_child_edge_id = to_child_edge['@id']
        par = to_par_edge['@source']
        self._edge_by_source[par][to_child_edge_id] = to_child_edge
        to_child_edge['@source'] = par
        # make it a tip...
        del self._edge_by_source[nd_id]
        # delete it
        self._del_tip(nd_id)
1279973
function() {
			this.movingElement.css({
				zIndex: this.oldZIndex
			});
			if ( this.movingElement[0] !== this.element[0] ) {
				this.movingElement.css({
					display: 'none'
				});
			}
			if ( this._removeMovingElement ) {
				this.movingElement.remove();
			}

			this.movingElement = this.element = this.event = null;
		}
1301343
public boolean deleteEdgeReference(AtlasEdge edge, TypeCategory typeCategory, boolean isOwned,
                                       boolean forceDeleteStructTrait) throws AtlasBaseException {

        // default edge direction is outward
        return deleteEdgeReference(edge, typeCategory, isOwned, forceDeleteStructTrait, AtlasRelationshipEdgeDirection.OUT);
    }
668827
@Override
    public void removeEdge(Edge edge) {
        super.removeEdge(edge);

        // Keep track of removed edges.
        if (removedEdgeList == null) {
            removedEdgeList = new LinkedList<>();
        }
        removedEdgeList.add(edge);
    }
948125
def del_edge(self, edge):
        
        u, v = edge
        self.node_neighbors[u].remove(v)
        self.del_edge_labeling((u, v))  
        if (u != v):
            self.node_neighbors[v].remove(u)
            self.del_edge_labeling((v, u))
966557
function edgeCheck(offset){
			if(edgeClass){
				var box         = el.getBoundingClientRect();
				var windowEdge  = window.innerHeight;
				
				// If the bottom-edge is visible (or about to be), enable height animation
				if(box.bottom + (offset || 0) < windowEdge)
					elClasses.add(edgeClass)
				
				// If the bottom-edge isn't visible anyway, disable height animation immediately
				else if(box.bottom > windowEdge)
					elClasses.remove(edgeClass);
			}
		}
73077
def delete_edge(self, source: str, target: str):
        
        if self.has_edge(source, target):
            self.remove_edge(source, target)
1188768
function deinterlace(pixels, width) {

                    var newPixels = new Array(pixels.length);
                    var rows = pixels.length / width;
                    var cpRow = function(toRow, fromRow) {
                        var fromPixels = pixels.slice(fromRow * width, (fromRow + 1) * width);
                        newPixels.splice.apply(newPixels, [toRow * width, width].concat(fromPixels));
                    };

                    // See appendix E.
                    var offsets = [0, 4, 2, 1];
                    var steps = [8, 8, 4, 2];

                    var fromRow = 0;
                    for (var pass = 0; pass < 4; pass++) {
                        for (var toRow = offsets[pass]; toRow < rows; toRow += steps[pass]) {
                            cpRow(toRow, fromRow);
                            fromRow++;
                        }
                    }

                    return newPixels;
                }
192500
public void removeVertex(int i) {
        this.x.remove(i);
        this.y.remove(i);
        this.z.remove(i);
        this.colors.remove(i);
        calcG();
    }
523803
void deleteEdgesBreakFaces_(AttributeStreamOfInt32 edgesToDelete) {
		for (int i = 0, n = edgesToDelete.size(); i < n; i++) {
			int half_edge = edgesToDelete.get(i);
			int chain = getHalfEdgeChain(half_edge);
			int halfEdgeTwin = getHalfEdgeTwin(half_edge);
			int chainTwin = getHalfEdgeChain(halfEdgeTwin);
			setChainHalfEdge_(chain, -1);
			setChainHalfEdge_(chainTwin, -1);
			updateVertexToHalfEdgeConnection_(half_edge, true);
			deleteEdgeImpl_(half_edge);
		}
	}
274587
public void clearLensDistortion() {
		detector.clearLensDistortion();
		if( refineGray != null )
			refineGray.clearLensDistortion();
		edgeIntensity.setTransform(null);
	}