R树-javascript代码实现过程分析(插入操作)
R Tree
第一步,创建R树类。
构建一个RTree生成器。用以创建tree对象。
例子:var tree = new RTree(12)
var RTree = function(width){ var _Min_Width = 3; // Minimum width of any node before a merge var _Max_Width = 6; // Maximum width of any node before a split if(!isNaN(width)){ _Min_Width = Math.floor(width/2.0); _Max_Width = width;} // Start with an empty root-tree var _T = {x:0, y:0, w:0, h:0, id:"root", nodes:[] }; var isArray = function(o) { return Object.prototype.toString.call(o) === '[object Array]'; }; var _attach_data = function(node, more_tree){ node.nodes = more_tree.nodes; node.x = more_tree.x; node.y = more_tree.y; node.w = more_tree.w; node.h = more_tree.h; return(node); }; //选择适合的节点来存放插入的条目。 //@private。 var _choose_leaf_subtree = (rect, root) => {...} //内部插入函数。 //[] = _insert_subtree(rectangle, object to insert, root to begin insertion at) //@private。即私有函数,只能用RTree的方法调用它。 var _insert_subtree = (node, root) => {...} this.get_tree = function() { return _T} //new_tree代表新的子树节点,where代表要替代的位置。 this.set_tree = (new_tree, where) => { if (!where) { where = _T } return (_attach_data(where, new_tree)) } //rect是边界矩阵,对象是叶子节点。 this.insert = (rect, obj) => { if (arguments.length < 2) { throw "Wrong number of arguments" } return (_insert_subtree({x:rect.x, y:rect.y, w:rect.w, h:rect.h, leaf:obj}, _T)) } // End of RTree }
tree.insert方法,用以向生成的R树,插入数据。方法见下:
把一个新的索引条目E插入一个R树内:
- 找到插入新记录的位置: 这里要调用Choose Leaf方法,选择一个叶节点L来存放E。 把记录E加入到叶节点中: 这里需要进行判断。
- 如果L.nodes <= M(即L的条目数量此时小于等于规定的最大值M),则下一步;
- 否则, 需要分裂,调用Split Node方法。把叶子节点L分裂成2个新节点L和LL(2个新节点包含了原来的L节点的所有条目和新条目E)。
- 向上传递变化:调用Adjust Tree方法对L节点操作。如果上一步是分裂操作,则对2个新节点调用Adjust Tree方法。
- 判断:是否树增高。如果节点的分裂导致了root的分裂,则需要生成新的root,并且让它的两个孩子节点为原来的root分裂后产生的2个节点。
第二步:生成R树。
var tree = new RTree(12)、 tree.insert(rect, obj)
调用tree.insert(rect, obj)方法, 向R树插入数据,参数有2个,rect是边界矩阵对象,obj是节点对象。
由此,引入rectangle的构建器。
//Rectangle - 生成rectangle对象。 RTree.Rectangle = function(ix, iy, iw, ih) { var x, x2, y, y2, w, h; if(ix.x) { x = ix.x;y = ix.y; //得到左下角坐标 if(ix.w !== 0 && !ix.w && ix.x2){ //如果长,宽不存在,则计算出来。 w = ix.x2-ix.x; h = ix.y2-ix.y; } else { w = ix.w; h = ix.h; } x2 = x + w; y2 = y + h; //得到第右上角的坐标 } else { x = ix; y = iy; //得到左下角坐标 w = iw; h = ih; x2 = x + w; y2 = y + h; //得到第右上角的坐标 } this.x1 = this.x = x; this.y1 = this.y = y; this.x2 = x2; this.y2 = y2; this.w = w; this.h = h; //矩阵a和当前矩阵产生部分重合则,返回true。 this.overlap = (a) => {...} //扩展当前矩阵。根据传入的矩阵a,来扩展,包含矩阵a. this.expand = (a) => {...} //重置当前矩阵的坐标和长宽。代码同初始化Rectangle的代码。 this.setRect = (ix, iy, iw ,ih) {...} // End of Rectangle }
overlap方法的解释(代码):
expand方法的解释:
插入一个矩阵,到叶子节点,对应的父亲的最小边界矩阵由此可能要扩展。矩阵b要把插入的a的矩阵包含进自己。
this.expand = function(a) { var nx = Math.min(this.x(), a.x()); var ny = Math.min(this.y(), a.y()); w = Math.max(this.x2(), a.x2()) - nx; h = Math.max(this.y2(), a.y2()) - ny; x = nx; y = ny; return(this); };
第三步:插入方法讲解
这里要调用插入方法。
//得到一个最小边界矩阵。 var rect = new RTree.Rectangle(2,2,3,3)
var tree = new RTree(12)
tree.insert(rect, obj)
在插入一个rect后,为了要把rect放到正确的叶节点中。首先要找到这个叶节点,需要调用choose leaf方法。
//在insert方法内的_insert方法内调用 var tree_stack = _choose_leaf_subtree(node, root) //node参数就是最开始传入insert()的第一个参数
方法_choose_leaf_subtree:
//选择适合的节点来存放插入的条目。 //从root节点开始一路向下,每次找到当前节点的条目中,那个被插入新矩阵后,需要扩展最小的条目。就是被选择的条目。 //直到到达叶子节点。最后返回:从root节点到叶子节点,经过的节点的集合数组。 var _choose_leaf_subtree = (rect, root) => { var best_choice_index = -1; //记录最合适的节点索引,并用它来控制do..while循环 var best_choice_stack = []; //方法结束后,返回从root节点到叶子节点,经过的节点的集合数组。 var best_choice_area; //用于比较扩展的区域大小。 best_choice_stack.push(root); //返回的变量的第一个元素是root。 var nodes = root.nodes; //首先,变量nodes记录根节点的所有的条目,用于循环代码。 do { if(best_choice_index != -1){ best_choice_stack.push(nodes[best_choice_index]); //储存当前最合适的条目。 nodes = nodes[best_choice_index].nodes; //修改nodes,为被选中的条目的nodes集合。其实就是准备下一层的条目的判断。 best_choice_index = -1; } //第一次循环,遍历root的所有项目。 //变量:当前节点的所有条目/项目。找到添加rect后,扩展最小的那个条目。 //当i等于-1,当前节点的所有条目的判断结束, for(var i = nodes.length-1; i >= 0; i--) { var ltree = nodes[i]; //如果到达叶节点,结束for循环。leaf是hash对象的索引,由_insert_subtree传入。 if("leaf" in ltree) { best_choice_index = -1; //通过变量,同时也保证会退出do..while循环。 break; } //下面的代码用于计算当前条目被插入新矩阵后,扩展的面积。然后用best_choice_area记录最小的扩张面积。 //这里使用一种特殊的算法。 //原矩阵正方化。一种算法。 var old_lratio = RTree.Rectangle.squarified_ratio(ltree.w, ltree.h, ltree.nodes.length+1); // 扩展矩阵。 var nw = Math.max(ltree.x+ltree.w, rect.x+rect.w) - Math.min(ltree.x, rect.x); var nh = Math.max(ltree.y+ltree.h, rect.y+rect.h) - Math.min(ltree.y, rect.y); // 新扩展的矩阵的正方化。 var lratio = RTree.Rectangle.squarified_ratio(nw, nh, ltree.nodes.length+2); //扩展的面积的比较,我们需要用变量记录最小扩展面积。 if(best_choice_index < 0 || Math.abs(lratio - old_lratio) < best_choice_area) { best_choice_area = Math.abs(lratio - old_lratio); best_choice_index = i; } } } while(best_choice_index != -1) return(best_choice_stack) }
找到要插入的位置后,进行第2步判断是否需要分裂节点。
再然后进行第3步,向上调整边界矩阵。
- 这时要判断第二步是否有分裂节点的情况。如果是,那么对分裂出来的2个新节点的矩阵都要进行性调整。即调用RTree.Rectangle.expand_rectangle方法。
- 如果false。就对原来的节点调整。
最后一路到达根节点,同样对根节点进行第2步的判断,第3步的调整,最后完成插入操作。
看_insert_subtree
//[] = _insert_subtree(rectangle, object to insert, root to begin insertion at) //@private。即私有函数,只能用RTree的方法调用它。 var _insert_subtree = (node, root) => { var bc //Best current node // 初始化插入。如果根节点还没有儿子,那么这个节点的最小边界矩阵,就是root节点的MBR。 if (root.nodes.length == 0) { root.x = node.x; root.y = node.y; root.w = node.w; root.h = node.h; root.nodes.push(node); return; } //找到最适合的叶子节点来插入条目 var tree_stack = _choose_leaf_subtree(node, root) //return得到从root到叶子,经过的所有节点的集合。 var ret_obj = node //{x: rect.x, y:rect.y, w:rect.w, h:rect.h, leaf:obj}, 这个变量代表循环内要调整的条目。 //向上传递变化。包括插入的第2-4步骤,对tree_stack增减其中的元素,控制循环次数。 do { //第一次循环会调用else块的语句,bc被赋值为叶节点对象, 同时tree_stack也发生变化,用于控制循环。 if(bc && "nodes" in bc && bc.nodes.length == 0) { //handle the case of an empty node (from a split) 。 删除空节点。 var pbc = bc; // Past bc bc = tree_stack.pop(); for(var t=0; t<bc.nodes.length; t++) //for循环没有带{},⚠️这种写法 if(bc.nodes[t] === pbc || bc.nodes[t].nodes.length == 0) { bc.nodes.splice(t, 1); //删除这个条目。 break; } } else { bc = tree_stack.pop(); } // If there is data attached to this ret_obj, // 如果rec_obj对象含有属性"leaf",或"nodes",或一个数组(内含多2个新节点/条目) if("leaf" in ret_obj || "nodes" in ret_obj || isArray(ret_obj)) { // 调整和插入。 if(isArray(ret_obj)) { //如果上一轮循环是分裂情况,那么需要把分裂的节点放入父亲点,并调整矩阵。 for(var ai = 0; ai < ret_obj.length; ai++) { //让bc扩展到可以包含所有ret_obj内的条目。 RTree.Rectangle.expand_rectangle(bc, ret_obj[ai]); } bc.nodes = bc.nodes.concat(ret_obj); //叶节点bc的条目增加 } else { //正常情况,也是调整矩阵,然后插入。 RTree.Rectangle.expand_rectangle(bc, ret_obj); bc.nodes.push(ret_obj); // 插入一个条目到节点bc。 } //当插入完成后,第二步判断bc的条目是否超出最大值限制。 // true: rec_obj被重新赋值,因为没有"leaf",'nodes'属性,后续轮循环代表一路向上调整最小限定矩阵。 // false: 则需要分裂。然后也要对分裂后的节点进行调整。 if(bc.nodes.length <= _Max_Width) { ret_obj = {x:bc.x,y:bc.y,w:bc.w,h:bc.h}; //后续循环只需调整MBR。 } else { // 否则,要分裂 // 调用linear_split(),返回包括2个新节点的数组。 // formed from the split of the previous node's overflow var a = _linear_split(bc.nodes); ret_obj = a; //这时ret_obj是一个数组。 if(tree_stack.length < 1) { // 如果正在分裂root节点, tree_stack已经为空。这是插入操作的第4步。 bc.nodes.push(a[0]); tree_stack.push(bc); //重新考虑root元素。 ret_obj = a[1]; } /*else { delete bc; }*/ } } else { //插入操作第3步骤。 //如果不是上面的情况:rect_obj只是一个含有矩阵信息的对象。就只更新bc的最小限定矩阵。 RTree.Rectangle.expand_rectangle(bc, ret_obj); ret_obj = {x:bc.x,y:bc.y,w:bc.w,h:bc.h}; } }while(tree_stack.length > 0) }
根据插入操作的流程,可理解代码。这里还没有讲解分裂方法:_linear_split()。
为了优化R树,大神们开发了多种分裂算法。这里使用的是linear split。
具体看 Hilbert R树发展 这篇文章讲解了分裂算法的发展历史。
⚠️R*树的方法是对R树最好的优化。
分裂算法也是很复杂的。没有仔细理解这个分裂算法。
//split方法:分裂一个节点的条目,把它们放到2个新的节点中。⚠️分裂方法不同,放置也不同。这里使用linear split。 // [ an array of two new arrays of nodes ] = linear_split(array of nodes) // @private var _linear_split = function(nodes) { var n = _pick_linear(nodes); while(nodes.length > 0) { _pick_next(nodes, n[0], n[1]); } return(n); };
里面的私有方法:
- pcik_linear返回数组,把原来数组内的条目,分成2组。每组的条目属于一个新的节点。
- pick_next则是把最好的MBR插入到节点a, b。
具体代码见:https://github.com/imbcmdth/RTree/blob/master/src/rtree.js
关于插入操作就讲解完了。