void CKDTree::SearchTree(KD_Node *parent, Point &p, float radius, ivector &vec_r)
{
if (parent==NULL || parent->IsSearched)
return;
parent->IsSearched=true;
//is a child node
if(parent->m_left==NULL && parent->m_right==NULL)
{
int nSize=parent->m_vecIn.size();
for (int i=0; i<nSize; ++i)
if(m_regionArray[parent->m_vecIn[i]].IsSeen(p, radius))
vec_r.push_back(parent->m_vecIn[i]);
}
//not a child node
else
{
if(parent->m_left!=NULL && !parent->m_left->IsSearched &&
(parent->m_left->m_regOverlap.IsSeen(p, radius)))
SearchTree(parent->m_left, p, radius, vec_r);
if (parent->m_right!=NULL && !parent->m_right->IsSearched &&
(parent->m_right->m_regOverlap.IsSeen(p, radius)))
SearchTree(parent->m_right, p, radius, vec_r);
}
//back trace : search parent
SearchTree(parent->m_parent, p, radius, vec_r);
}
void CCJShellTree::TunnelTree(CString strFindPath)
{
HTREEITEM subNode = GetRootItem();
CString szPathHop;
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
char delimiter[]="\\";
m_bRefresh = false;
if(!m_shell.Exist(strFindPath))
{
if (strFindPath.GetLength() == 3)
{
}
else
{
MessageBox(strFindPath,_T("Folder not found"),MB_ICONERROR);
return;
}
}
if(strFindPath.ReverseFind(_T('\\')) != strFindPath.GetLength()-1)
{
strFindPath += _T("\\");
}
m_shell.SplitPath(strFindPath,drive,dir,fname,ext);
//search the drive first
szPathHop=drive;
subNode=GetChildItem(subNode);
if(subNode)
{
if(SearchTree(subNode,szPathHop, CCJShellTree::type_drive))
{
SetRedraw(FALSE);
//break down subfolders and search
char *p=strtok(dir,delimiter);
while(p)
{
subNode = GetSelectedItem();
Expand(subNode, TVE_EXPAND);
subNode = GetChildItem(subNode);
if(SearchTree(subNode,p,CCJShellTree::type_folder))
p=strtok(NULL,delimiter);
else
p=NULL;
}
SetRedraw();
}
}
}
NodeTree* SearchTree(NodeTree* ApT, key k) {
if(ApT == NULL) {
return NULL;
}
else if (ApT->info == k) {
return ApT;
}
else if (ApT->info > k) {
return SearchTree(ApT->left, k);
}
else {
return SearchTree(ApT->right, k);
}
}
//search the tree
void CKDTree::SearchTree(Point &p, float radius, ivector &vec_r)
{
ResetTree(m_root);
KD_Node *n=m_pRecentRoot;
if (n==NULL)
{
n=m_root;
}
else
{
n=m_pRecentRoot;
while(n!=m_root && !n->m_regOverlap.IsIn(p))
n=n->m_parent;
}
while(n!=NULL && (n->m_left!=NULL || n->m_right!=NULL))
{
if (n->IsSplitX)
{
if(p.m_x<n->m_nMedian)
n=n->m_left;
else
n=n->m_right;
}
else
{
if(p.m_y<n->m_nMedian)
n=n->m_left;
else
n=n->m_right;
}
}
m_pRecentRoot=n;
SearchTree(n, p, radius, vec_r);
}
/* #FN#
Pushes down and selects an item one level at a time until either we
can't find anymore parts of the path, or we've finished searching
Doesn't work on network (UNC) paths (Could search NETHOOD when
prefix is \\) */
void
/* #AS#
Nothing */
CShellTree::
TunnelTree(
LPCSTR lpszPath /* #IN# */
)
{
char szSearchPath[ MAX_PATH + 1 ];
BOOL bFound = FALSE;
int i = 0;
HTREEITEM hTopLevelItem;
HTREEITEM hItem;
if( (hTopLevelItem = GetRootItem()) )
{
do /* Enumerate the top level items */
{
if( Expand( hTopLevelItem, TVE_EXPAND ) )
{
hItem = GetChildItem( hTopLevelItem );
while( hItem )
{
for( ; i < (int)strlen( lpszPath ) && lpszPath[ i ] != '\\'; i++ )
szSearchPath[ i ] = lpszPath[ i ];
szSearchPath[ i++ ] = '\0';
/* Add ending backslash to drive name */
if( strlen( szSearchPath ) == 2 && szSearchPath[ 1 ] == ':' )
strcat( szSearchPath, "\\" );
if( SearchTree( hItem, szSearchPath ) )
{
hItem = GetSelectedItem();
if( Expand( hItem, TVE_EXPAND ) )
{
/* Get first leaf of the new bunch */
hItem = GetChildItem( hItem );
}
bFound = TRUE;
}
else
break;
/* Append a folder delimiter */
szSearchPath[ i - 1 ] = '\\';
}
/* The path has not been found, reset the searching "engine" */
if( !bFound )
{
Expand( hTopLevelItem, TVE_COLLAPSE );
i = 0;
}
}
}
while( !bFound && (hTopLevelItem = GetNextSiblingItem( hTopLevelItem )) );
}
} /* #OF# CShellTree::TunnelTree */
ENVITEM * NS_PREFIX SearchEnv (const char *name, const char *where, INT type, INT dirtype)
{
/* check if search directory is changed */
if (strcmp(where,".")!=0)
if (ChangeEnvDir(where)==NULL) return(NULL);
/* recursive search */
return(SearchTree(name,type,dirtype));
}
ND* SearchTree(const ND* node, char* searchString)
{
ND* found = NULL;
if (node == NULL) {
return (ND*)found;
}
if (strcmp(node->text, searchString) == 0) {
return (ND*)node;
}
if ((found = SearchTree(node->next, searchString)) != NULL) {
return found;
}
if ((found = SearchTree(node->children, searchString)) != NULL) {
return found;
}
return found;
}
D3DXVECTOR3 QuadTree::PlaceATower(D3D10_VIEWPORT vp, POINT mouse)
{
D3DXVECTOR3 vPickRayDir;
D3DXVECTOR3 vPickRayOrig;
GenerateMouse3DPos(vp, mouse, vPickRayDir, vPickRayOrig);
SearchTree(vPickRayDir, vPickRayOrig, getBLS());
D3DXVECTOR3 ret = newTowerPos;
newTowerPos = D3DXVECTOR3(-99,-99,-99);
return ret;
}
bool SearchTree(TreeNode *root,int key, int &ret)
{
if (root) {
if (root->Key > key)
{
//std::cout << root->Key << std::endl;
SearchTree (root->Left,key, ret);
} else if (root->Key < key)
{
//std::cout << root->Key << std::endl;
SearchTree(root->Right,key, ret);
} else if (root->Key == key)
{
//std::cout << root->Key << std::endl;
ret = true;
return true;
}
}
// std::cout << root << std::endl;
return false;
}
void QuadTree::SearchTree(D3DXVECTOR3 vPickRayDir, D3DXVECTOR3 vPickRayOrig, BoxNode box)
{
bool result = false;
result = Pick(vPickRayDir, vPickRayOrig, box);
if (!result)
return;
if (!box.ChildNode.empty())
{
for (int i=0; i<4; ++i)
SearchTree(vPickRayDir, vPickRayOrig, box.ChildNode.at(i));
return;
}
newTowerPos.x = (box.minB.x+box.maxB.x)/2;
newTowerPos.z = (box.minB.z+box.maxB.z)/2;
newTowerPos.y = pLand->getHeight(newTowerPos.x, newTowerPos.z)+1;
return;
}
static ENVITEM *SearchTree (const char *name, INT type, INT dirtype)
{
ENVDIR *currentDir;
ENVITEM *theItem,*result;
currentDir = path[pathIndex];
/* first loop in current directory */
theItem = currentDir->down;
while (theItem!=NULL)
{
if (theItem->v.type == type)
if (strcmp(theItem->v.name,name)==0)
return(theItem);
theItem = theItem->v.next;
}
/* try recursive search */
theItem = currentDir->down;
while (theItem!=NULL)
{
if (theItem->v.type%2 == 1)
{
/* this is a directory */
if ((theItem->d.type==dirtype)||(dirtype==SEARCHALL))
{
path[++pathIndex] = (ENVDIR *) theItem;
if ((result=SearchTree(name,type,dirtype))!=NULL)
return(result);
pathIndex--;
}
}
theItem = theItem->v.next;
}
/* return not found */
return(NULL);
}
// Function which deletes subscriber from the tree
void DeleteSubscriber(SUBSCRIBER **tree, LONG_MAC mac) {
SUBSCRIBER *parent, *tmp, *tmpsucc;
// Return if tree is empty
if ((*tree) == NULL) return;
// If the subscriber doesn't exist, return from function
if (FindSubscriberMAC(tree, mac) == NULL) return;
// Otherwise find parent of element
parent = tmp = NULL;
SearchTree(tree, mac, &parent, &tmp);
// If the node to be deleted has two children
if ( (tmp->left != NULL) && (tmp->right != NULL) )
{
parent = tmp;
tmpsucc = tmp->right;
while (tmpsucc->left != NULL)
{
parent = tmpsucc;
tmpsucc = tmpsucc->left;
}
tmp->mac = tmpsucc->mac;
tmp->ip = tmpsucc->ip;
tmp->session_id = tmpsucc->session_id;
tmp = tmpsucc;
}
// If the node to be deleted has no children
if ( (tmp->left == NULL) && (tmp->right == NULL) )
{
if (parent == NULL) (*tree) = NULL;
else if (parent->right == tmp) parent->right = NULL;
else parent->left = NULL;
free (tmp);
return;
}
// If the node to be deleted has only rightchild
if ( (tmp->left == NULL) && (tmp->right != NULL) )
{
if (parent == NULL) (*tree) = tmp->right;
else if (parent->left == tmp) parent->left = tmp->right;
else parent->right = tmp->right;
free (tmp);
return;
}
// If the node to be deleted has only left child
if ( (tmp->left != NULL) && (tmp->right == NULL) )
{
if (parent == NULL) (*tree) = tmp->left;
else if (parent->left == tmp) parent->left = tmp->left;
else parent->right = tmp->left;
free (tmp);
return;
}
}
/** fast NFFT-based summation */
void fastsum_trafo(fastsum_plan *ths)
{
int j,k,t;
ticks t0, t1;
ths->MEASURE_TIME_t[4] = 0.0;
ths->MEASURE_TIME_t[5] = 0.0;
ths->MEASURE_TIME_t[6] = 0.0;
ths->MEASURE_TIME_t[7] = 0.0;
#ifdef MEASURE_TIME
t0 = getticks();
#endif
/** first step of algorithm */
nfft_adjoint(&(ths->mv1));
#ifdef MEASURE_TIME
t1 = getticks();
ths->MEASURE_TIME_t[4] += nfft_elapsed_seconds(t1,t0);
#endif
#ifdef MEASURE_TIME
t0 = getticks();
#endif
/** second step of algorithm */
#pragma omp parallel for default(shared) private(k)
for (k=0; k<ths->mv2.N_total; k++)
ths->mv2.f_hat[k] = ths->b[k] * ths->mv1.f_hat[k];
#ifdef MEASURE_TIME
t1 = getticks();
ths->MEASURE_TIME_t[5] += nfft_elapsed_seconds(t1,t0);
#endif
#ifdef MEASURE_TIME
t0 = getticks();
#endif
/** third step of algorithm */
nfft_trafo(&(ths->mv2));
#ifdef MEASURE_TIME
t1 = getticks();
ths->MEASURE_TIME_t[6] += nfft_elapsed_seconds(t1,t0);
#endif
#ifdef MEASURE_TIME
t0 = getticks();
#endif
/** add near field */
#pragma omp parallel for default(shared) private(j,k,t)
for (j=0; j<ths->M_total; j++)
{
double ymin[ths->d], ymax[ths->d]; /** limits for d-dimensional near field box */
if (ths->flags & NEARFIELD_BOXES)
{
ths->f[j] = ths->mv2.f[j] + SearchBox(ths->y + ths->d*j, ths);
}
else
{
for (t=0; t<ths->d; t++)
{
ymin[t] = ths->y[ths->d*j+t] - ths->eps_I;
ymax[t] = ths->y[ths->d*j+t] + ths->eps_I;
}
ths->f[j] = ths->mv2.f[j] + SearchTree(ths->d,0, ths->x, ths->alpha, ymin, ymax, ths->N_total, ths->k, ths->kernel_param, ths->Ad, ths->Add, ths->p, ths->flags);
}
/* ths->f[j] = ths->mv2.f[j]; */
/* ths->f[j] = SearchTree(ths->d,0, ths->x, ths->alpha, ymin, ymax, ths->N_total, ths->k, ths->kernel_param, ths->Ad, ths->Add, ths->p, ths->flags); */
}
#ifdef MEASURE_TIME
t1 = getticks();
ths->MEASURE_TIME_t[7] += nfft_elapsed_seconds(t1,t0);
#endif
}
/** fast search in tree of source knots for near field computation*/
double _Complex SearchTree(const int d, const int t, const double *x,
const double _Complex *alpha, const double *xmin, const double *xmax,
const int N, const kernel k, const double *param, const int Ad,
const double _Complex *Add, const int p, const unsigned flags)
{
int m=N/2;
double Min=xmin[t], Max=xmax[t], Median=x[m*d+t];
double a=fabs(Max-Min)/2;
int l;
int E=0;
double r;
if (N==0)
return 0.0;
if (Min>Median)
return SearchTree(d,(t+1)%d,x+(m+1)*d,alpha+(m+1),xmin,xmax,N-m-1,k,param,Ad,Add,p,flags);
else if (Max<Median)
return SearchTree(d,(t+1)%d,x,alpha,xmin,xmax,m,k,param,Ad,Add,p,flags);
else
{
double _Complex result = 0.0;
E=0;
for (l=0; l<d; l++)
{
if ( x[m*d+l]>xmin[l] && x[m*d+l]<xmax[l] )
E++;
}
if (E==d)
{
if (d==1)
{
r = xmin[0]+a-x[m]; /* remember: xmin+a = y */
}
else
{
r=0.0;
for (l=0; l<d; l++)
r+=(xmin[l]+a-x[m*d+l])*(xmin[l]+a-x[m*d+l]); /* remember: xmin+a = y */
r=sqrt(r);
}
if (fabs(r)<a)
{
result += alpha[m]*k(r,0,param); /* alpha*(kern-regkern) */
if (d==1)
{
if (flags & EXACT_NEARFIELD)
result -= alpha[m]*regkern1(k,r,p,param,a,1.0/16.0); /* exact value (in 1D) */
else
result -= alpha[m]*kubintkern1(r,Add,Ad,a); /* spline approximation */
}
else
{
if (flags & EXACT_NEARFIELD)
result -= alpha[m]*regkern(k,r,p,param,a,1.0/16.0); /* exact value (in dD) */
else
#if defined(NF_KUB)
result -= alpha[m]*kubintkern(r,Add,Ad,a); /* spline approximation */
#elif defined(NF_QUADR)
result -= alpha[m]*quadrintkern(r,Add,Ad,a); /* spline approximation */
#elif defined(NF_LIN)
result -= alpha[m]*linintkern(r,Add,Ad,a); /* spline approximation */
#else
#error define interpolation method
#endif
}
}
}
result += SearchTree(d,(t+1)%d,x+(m+1)*d,alpha+(m+1),xmin,xmax,N-m-1,k,param,Ad,Add,p,flags)
+ SearchTree(d,(t+1)%d,x,alpha,xmin,xmax,m,k,param,Ad,Add,p,flags);
return result;
}
}
//----------------------------------------------------------------------------
//
// build kd tree (prototype)
//
// pts: point locations to be indexed in kd-tree (for now)
// loc_num_pats: local number of points
// glo_num_pats: global number of points
// num_levels: number of tree levels, counting root
// num_bins: number of histogram bins at all levels
//
void Blocking::BuildTree(float *pts, int loc_num_pts, int glo_num_pts,
int num_levels, int num_bins) {
int num_hists; // number of historgrams in this level
int median = glo_num_pts / 2; // desired median
int parent = 0; // curent parent tree node
int tot_num_bins; // total number of bins in all histograms for a block
// headers for each block
int **hdrs = new int*[nb];
for (int i = 0; i < nb; i++)
hdrs[i] = new int[1];
// todo: only the right number of bins for global range
// yet to implement local ranges, especially for later levels
// allocate histograms, hists[i] allocated and freed during each level
int **hists;
hists = new int*[nb];
// initialize kd-tree with level 0
kd_node_t node;
for (int i = 0; i < dim; i++) {
node.bounds.min[i] = data_min[i];
node.bounds.max[i] = data_max[i];
}
node.proc = 0; // default
node.l_child = -1; // empty, to be filled in later
node.r_child = -1; // ditto
node.parent = -1; // will remain empty for root
kd_tree.push_back(node);
for (int level = 1; level < num_levels; level++) { // tree levels
int dir = (level - 1) % dim;
num_hists = ((level - 1) ? num_hists * 2 : 1);
// toto: reduce histogram size with level (after one full cycle of all dirs)
// turned off for now
// if (level - 1)
// num_bins = (num_bins >= 2 * min_num_bins ? num_bins / 2 : min_num_bins);
tot_num_bins = num_hists * num_bins;
for (int b = 0; b < nb; b++)
hists[b] = new int[tot_num_bins];
// init histograms
for (int b = 0; b < nb; b++) {
for (int i = 0; i < tot_num_bins; i++)
hists[b][i] = 0;
}
for (int b = 0; b < nb; b++) { // local blocks
// scan and bin objects
// todo: is data_max and data_min set correctly? I doubt it for particles
float bin_width = (data_max[dir] - data_min[dir]) / num_bins;
for (int i = 0; i < loc_num_pts; i++) {
// search for particle in tree
// todo: don't have to start at root each time
int pt_node = SearchTree(&pts[3 * i], 0);
// pos of node in level
int temp = (int)(pow(2, level - 1));
int node_level_pos = pt_node + 1 - temp;
// debug
// fprintf(stderr, "pt: %.1f %.1f %.1f in node %d: node_level_pos %d\n",
// pts[3 * i], pts[3 * i + 1], pts[3 * i + 2],
// pt_node, node_level_pos);
int bin = pts[3 * i + dir] / bin_width;
if (bin >= num_bins)
bin = num_bins - 1;
bin += num_bins * node_level_pos; // move to correct histogram
hists[b][bin]++;
} // objects
hdrs[b][0] = tot_num_bins;
} // local blocks
// debug: print the histograms
// for (int b = 0; b < nb; b++) {
// for (int i = 0; i < num_bins; i++)
// fprintf(stderr, "hists[%d][%d] = %d\n", b, i, hists[b][i]);
// }
// merge the histograms
// todo: change merge and swap API to take a target k and figure out
// rounds and kvalues itself
int rounds = log2f((float)tot_b); // todo: assumes power of 2 blocks
int kvalues[rounds];
for (int i = 0; i < rounds; i++)
kvalues[i] = 2;
int nb_merged; // number of output merged blocks
DIY_Merge_blocks(did, (char**)hists, hdrs, rounds, kvalues,
&KdTree_MergeHistogram, &KdTree_CreateHistogram,
&KdTree_DestroyHistogram,
&KdTree_CreateHistogramType, &nb_merged);
// find median split points in histograms
int split_index[num_hists]; // split indices in cumulative mass function
if (rank == groupsize - 1) {
assert(nb_merged == 1); // sanity
// debug: print the merged histogram
// for (int i = 0; i < num_bins; i++)
// fprintf(stderr, "hist[%d] = %d\n", i, hists[0][i]);
// convert histogram to cumulative mass function; prefix sum
for (int i = 0; i < num_hists; i++) {
int ofst = i * num_bins; // start of this histogram
for (int j = 1; j < num_bins; j++)
hists[0][ofst + j] += hists[0][ofst + j - 1];
}
// debug: print the CMF
// for (int i = 0; i < num_bins; i++)
// fprintf(stderr, "cmf[%d] = %d\n", i, hists[0][i]);
// find split index of CMF
for (int i = 0; i < num_hists; i++) {
int ofst = i * num_bins; // start of this histogram
split_index[i] = BinarySearch(ofst, num_bins, hists[0], median);
// debug
fprintf(stderr, "level = %d split_index[%d] = %d median = %d\n",
level, i, split_index[i], median);
}
}
// broadcast the split points
MPI_Bcast(split_index, num_hists, MPI_INT, groupsize - 1, comm);
// add new level to kd-tree
for (int i = 0; i < num_hists; i++) {
int ofst = i * num_bins; // start of this histogram
AddChildren(parent + i, dir, ((float)split_index[i] - ofst)/ num_bins);
}
parent += num_hists;
median /= 2;
// cleanup
for (int b = 0; b < nb; b++)
delete[] hists[b];
// debug: print the kd tree
// if (rank == 0) { // duplicated on all ranks, print only once
// for (int i = 0; i < kd_tree.size(); i++)
// fprintf(stderr, "kd tree node %d: proc %d min[%.1f %.1f %.1f] "
// "max[%.1f %.1f %.1f] l_child %d r_child %d parent %d\n",
// i, kd_tree[i].proc, kd_tree[i].bounds.min[0],
// kd_tree[i].bounds.min[1], kd_tree[i].bounds.min[2],
// kd_tree[i].bounds.max[0], kd_tree[i].bounds.max[1],
// kd_tree[i].bounds.max[2], kd_tree[i].l_child, kd_tree[i].r_child,
// kd_tree[i].parent);
// }
} // tree levels
// debug: print the kd tree
if (rank == 0) { // duplicated on all ranks, print only once
for (int i = 0; i < (int)kd_tree.size(); i++)
fprintf(stderr, "kd tree node %d: proc %d min[%.1f %.1f %.1f] "
"max[%.1f %.1f %.1f] l_child %d r_child %d parent %d\n",
i, kd_tree[i].proc, kd_tree[i].bounds.min[0],
kd_tree[i].bounds.min[1], kd_tree[i].bounds.min[2],
kd_tree[i].bounds.max[0], kd_tree[i].bounds.max[1],
kd_tree[i].bounds.max[2], kd_tree[i].l_child, kd_tree[i].r_child,
kd_tree[i].parent);
}
// cleanup
delete[] hists;
}
bool BTree::Find(int key) const
{
int ret=false;
SearchTree(root, key,ret);
return ret;
}
/****************************************************************************
*
* FUNCTION: TunnelTree(CString szFindPath)
*
* PURPOSE: Too crude to explain, just use it
*
* WARNING: Only works if you use the default PopulateTree()
* Not guaranteed to work on any future or existing
* version of windows. Use with caution. Pretty much
* ok if you're using on local drives
*
****************************************************************************/
void CShellTreeCtrl::TunnelTree(CString szFindPath)
{
HTREEITEM subNode = GetRootItem();
CString szPathHop;
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
char delimiter[]="\\";
// LPTVITEMDATA lptvid; //Long pointer to TreeView item data
// HRESULT hr;
LPSHELLFOLDER lpsf2=NULL;
static char szBuff[MAX_PATH];
// TV_SORTCB tvscb;
CFileName checkPath(szFindPath);
if(!checkPath.Exist())
{
MessageBox(szFindPath,"Folder not found",MB_ICONERROR);
return;
}
if(szFindPath.ReverseFind('\\') != szFindPath.GetLength()-1)
{
szFindPath += "\\";
}
_splitpath(szFindPath,drive,dir,fname,ext);
//search the drive first
bool found = false;
szPathHop=drive;
subNode=GetChildItem(subNode);
if(subNode)
{
found = SearchTree(subNode,szPathHop, CShellTreeCtrl::type_drive);
if(!found)
{
subNode = GetRootItem();
subNode = GetNextSiblingItem(subNode);
Expand(subNode, TVE_EXPAND);
subNode = GetChildItem(subNode);
if(subNode)
found = SearchTree(subNode,szPathHop, CShellTreeCtrl::type_drive);
}
if(found)
{
//break down subfolders and search
char *p=strtok(dir,delimiter);
while(p)
{
subNode = GetSelectedItem();
//expand it
Expand(subNode, TVE_EXPAND);
subNode = GetChildItem(subNode);
if(SearchTree(subNode,p,CShellTreeCtrl::type_folder))
p=strtok(NULL,delimiter);
else
p=NULL;
}
}
}
}