UInt32 ParticleBSPTree::doBuild(std::vector<Int32>::iterator begin, std::vector<Int32>::iterator end, UInt32 nodeindex, GeoVectorProperty *pos) { // reached a leaf? if(begin + 1 == end) { _tree[nodeindex].setValue(*begin); return nodeindex + 1; } // find the bounding volume of the group BoxVolume b; Pnt3f p; b.setEmpty(); for(std::vector<Int32>::iterator i = begin; i != end; ++i) { pos->getValue(p,*i); b.extendBy(p); } // find the axis with the longest extension Vec3f d = b.getMax() - b.getMin(); UInt8 axis = ParticleBSPNode::X; Real32 maxval = d[0]; if(d[1] > maxval) { axis = ParticleBSPNode::Y; maxval = d[1]; } if(d[2] > maxval) { axis = ParticleBSPNode::Z; maxval = d[2]; } // sort in that axis ParticleCompare comp(pos, axis); std::sort(begin,end,comp); // find median value std::vector<Int32>::iterator mid = begin + (end - begin) / 2; Pnt3f p2; pos->getValue(p ,*mid); pos->getValue(p2,(*mid)-1); _tree[nodeindex].setSplit(axis, (p[axis] + p2[axis]) / 2.f); return osgMax( doBuild(begin, mid, nodeindex * 2 , pos), doBuild( mid, end, nodeindex * 2 + 1, pos) ); }
void doBuild(SegmentTreeNode* node){ if(node->start == node->end) return; SegmentTreeNode* left = new SegmentTreeNode(node->start, (node->start + node->end) / 2); SegmentTreeNode* right = new SegmentTreeNode((node->start + node->end) / 2 + 1, node->end); node->left = left; node->right = right; doBuild(left); doBuild(right); }
TreeNode *doBuild(vector<int> &inorder, int in_b, int in_e, vector<int> &postorder, int post_b, int post_e) { if (post_b >= post_e) return NULL; int mid = postorder[post_e - 1]; TreeNode *root = new TreeNode(mid); for (int i = in_b; i < in_e; i++) { if (inorder[i] == mid) { root->left = doBuild(inorder, in_b, i, postorder, post_b, post_b + i - in_b); root->right = doBuild(inorder, i + 1, in_e, postorder, post_b + i - in_b, post_e - 1); } } return root; }
/** *@param start, end: Denote an segment / interval *@return: The root of Segment Tree */ SegmentTreeNode * build(int start, int end) { // write your code here if(start > end) return nullptr; SegmentTreeNode* root = new SegmentTreeNode(start, end); doBuild(root); return root; }
// build Tan(a) DWPOINT* MathDraw::buildTan(DWPOINT* gPt,int ptCnt) { // if got null array - return null if (gPt==NULL) return NULL; return doBuild(gPt,NULL,ptCnt,&MathDraw::calcTan); }
void Constraint::build(double dt, MlcpPhysicsProblem* mlcp, size_t indexOfRepresentation0, size_t indexOfRepresentation1, size_t indexOfConstraint) { doBuild(dt, *m_data.get(), mlcp, indexOfRepresentation0, indexOfRepresentation1, indexOfConstraint); }
// common build function for string data DWPOINT* MathDraw::doBuild(char* str, int n, int ptCnt, char a, double (MathDraw::* func)(double, double)) { DWPOINT *pO1=NULL; DWPOINT *pO2=NULL; // get operands, if any if ( getOperands(str, n, &pO1, &pO2, a) ) return NULL; return doBuild(pO1,pO2,ptCnt,func); }
void ParticleBSPTree::build(Particles *core) { _tree.clear(); if(core == NULL) { FWARNING(("ParticleBSP::build: no core!!\n")); return; } GeoVectorProperty * const pos = core->getPositions(); if(pos == NULL) return; const MFInt32 *indices = core->getMFIndices(); // 1. create list for particles std::vector<Int32> order; order.reserve(pos->size()); for(UInt32 i = 0; i < pos->size32(); ++i ) { if(indices->size() == pos->size()) { order.push_back((*indices)[i]); } else { order.push_back(i); } } // reserve mem for tree _tree.resize(osgNextPower2(order.size()) * 2); // 2. recursively build the tree UInt32 nnodes = doBuild(order.begin(), order.end(), 1, pos); // 3. remove the unneeded elements from the end if(nnodes < _tree.size()) _tree.erase( _tree.begin() + nnodes, _tree.end()); // done }
// build (a^b) - powering DWPOINT* MathDraw::buildPow(char* str, int n, int ptCnt) { return doBuild(str, n, ptCnt, '^', &MathDraw::calcPow); }
// build (a-b) DWPOINT* MathDraw::buildMinus(char* str, int n, int ptCnt) { return doBuild(str, n, ptCnt, '-', &MathDraw::calcMinus); }
// build (a+b) DWPOINT* MathDraw::buildPlus(char* str, int n, int ptCnt) { return doBuild(str, n, ptCnt, '+', &MathDraw::calcPlus); }
// build (a/b) DWPOINT* MathDraw::buildDiv(char* str, int n, int ptCnt) { return doBuild(str, n, ptCnt, '/', &MathDraw::calcDiv); }
// build (a*b) DWPOINT* MathDraw::buildMltpl(char* str, int n, int ptCnt) //умножаем { return doBuild(str, n, ptCnt, '*', &MathDraw::calcMltpl); }
// build func(X) DWPOINT* MathDraw::buildX(int ptCnt) { return doBuild((double)alterStartPt_,ptCnt,&MathDraw::dltX); }
// build func(N) DWPOINT* MathDraw::buildLine(double dg,int ptCnt) { return doBuild(dg,ptCnt,&MathDraw::calcLine); }
TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) { // Start typing your C/C++ solution below // DO NOT write int main() function return doBuild(inorder, 0, inorder.size(), postorder, 0, postorder.size()); }