void KDTree<Dim>::buildKDTree(int dimension, int bottom, int top)
{
if(top == bottom)
{
return; //"base case"
}
int middle = (top+bottom)/2;//declare middle
//call the "choose" helper function to sort of split this thing
choose(middle, bottom, top, dimension);
if(top > middle) //check upper end
{
//make recursive call
buildKDTree((dimension+1)%Dim, middle+1, top); //call this thing on the upper end
}
if(bottom < middle) //check lower end
{
//make recursive call
buildKDTree((dimension+1)%Dim, bottom, middle-1); //call this thing on the lower end
}
}
Node* buildKDTree(const PrimList& prims, const Aabb& box, int depth = 0) {
if (prims.size() < 4)
return Node::make(prims);
if (depth >= 20)
return Node::make(prims);
Aabb leftBox, rightBox;
uint8_t axis = 3;
const floating split = getOptimalSplitPosition(prims, box, axis);
box.split_at(leftBox, rightBox, axis, split);
if (leftBox.volume() <= epsilon || rightBox.volume() <= epsilon)
return Node::make(prims);
PrimList lefts, rights;
for (auto p : prims) {
if (p->getLeftExtreme(axis) < split) {
lefts.push_back(p);
}
if (p->getRightExtreme(axis) >= split) {
rights.push_back(p);
}
}
Node* out = Node::make();
out->m_split = split;
out->m_axis = axis;
out->m_left = buildKDTree(lefts, leftBox, depth + 1);
out->m_right = buildKDTree(rights, rightBox, depth + 1);
return out;
}
void IntegralImages::load(QString path, QStringList fileNameList, bool treeNeeded, Parameter parameter_p){
clean(); // clean the last round
parameter = parameter_p;
//compute the parameter related variable
patchStepUpper = parameter.patchSizeUpper - parameter.OverlapSizeUpper;
numIndexPatchColUpper = (imageCol - parameter.patchSizeUpper)/patchStepUpper + 1;
numIndexPatchRowUpper = (imageRow - parameter.patchSizeUpper)/patchStepUpper + 1;
patchStepLower = parameter.patchSizeLower - parameter.OverlapSizeLower;
numIndexPatchColLower = (imageCol - parameter.patchSizeLower)/patchStepLower + 1;
numIndexPatchRowLower = (imageRow - parameter.patchSizeLower)/patchStepLower + 1;
commonTool.log(QString("Loading %1 images from path %2.").arg(fileNameList.size()).arg(qPrintable(path)));
for (int i = 0; i < fileNameList.size(); i++) {
QString imagePath;
imagePath = path + "/" + fileNameList.at(i);
commonTool.log(QString("Loading %1.").arg(fileNameList.at(i)));
IntegralImage* const image = new IntegralImage(imagePath);
integralImages.push_back(image);
}
imageRow = integralImages[0]->getImageRow();
imageCol = integralImages[0]->getImageCol();
if (treeNeeded == true){
commonTool.log("Building upper face synthesize tree.");
buildKDTree(_INTEGRALIMAGES_UPPER_);
commonTool.log("Building lower face synthesize tree.");
buildKDTree(_INTEGRALIMAGES_LOWER_);
}
}
void KDTree::buildKDTree(KDNode *root, const std::vector<KDTuple> &points, KDSplitAxis axis)
{
if (root == NULL || points.size() <= 0) return;
if (points.size() == 1)
{
root->points.push_back(points[0]);
return;
}
std::vector<double> splitValues;
for (size_t i = 0; i < points.size(); i++)
{
splitValues.push_back(points[i][axis]);
}
std::sort(splitValues.begin(), splitValues.end());
double middle = findMiddleValue(splitValues);
KDSplitAxis next = (KDSplitAxis)(1 - axis);
std::vector<KDTuple> leftPoints;
std::vector<KDTuple> rightPoints;
for (size_t i = 0; i < points.size(); i++)
{
double val = points[i][axis];
if (val < middle)
{
leftPoints.push_back(points[i]);
}
else if (val > middle)
{
rightPoints.push_back(points[i]);
}
else
{
root->points.push_back(points[i]);
}
}
if (leftPoints.size() > 0)
{
root->left = new KDNode(next);
root->left->parent = root;
buildKDTree(root->left, leftPoints, next);
}
if (rightPoints.size() > 0) {
root->right = new KDNode(next);
root->right->parent = root;
buildKDTree(root->right, rightPoints, next);
}
}
void Shape::init(VertexList& vertexList, FaceList& faceList, STLVectorf& UVList)
{
setVertexList(vertexList);
setFaceList(faceList);
setUVCoord(UVList);
color_list.resize(vertex_list.size(), 0.5);
std::cout<<"Building face adjacent list...\n";
buildFaceAdj();
std::cout<<"Building 1-ring neighbors list...\n";
buildVertexShareFaces();
std::cout<<"Building vertex adjacent list...\n";
buildVertexAdj();
std::cout << "Building edge connectivity...\n";
computeEdgeConnectivity();
std::cout<<"Computing bounding box...\n";
computeBounds();
std::cout<<"Computing face normals...\n";
computeFaceNormal();
computeVertexNormal();
buildKDTree();
}
void Shape::updateShape(VertexList& new_vertex_list)
{
vertex_list = new_vertex_list;
computeFaceNormal();
computeVertexNormal();
computeBounds();
buildKDTree();
}
KDTree<Dim>::KDTree(const vector< Point<Dim> > & newPoints)
{
/**
* @todo Implement this function!
*/
points = newPoints;
if(points.size() != 0)//if points isn't empty
{
//call the helper and build this thing!
buildKDTree(0, 0, newPoints.size()-1);//dont forget -1 to account for zeroth term;
}
}
void KdTreePrimitiveManager::init() {
if (m_prims.empty())
return;
for (uint8_t i = 0; i < 3; ++i) {
m_bbox.m_p1[i] = m_prims.front()->getLeftExtreme(i);
m_bbox.m_p2[i] = m_prims.front()->getRightExtreme(i);
}
for (auto prim : m_prims) {
for (uint8_t i = 0; i < 3; ++i) {
const floating l = prim->getLeftExtreme(i);
const floating r = prim->getRightExtreme(i);
m_bbox.m_p1[i] = fmin(m_bbox.m_p1[i], l);
m_bbox.m_p2[i] = fmax(m_bbox.m_p2[i], r);
}
}
m_root = buildKDTree(m_prims, m_bbox);
std::cerr << "KD Tree built! Tree has " << m_root->treeSize()
<< " nodes and has " << m_root->depth() << " levels."
<< std::endl;
}
void KDTreeRayTracer::setScene(Scene &sc)
{
scene = sc;
buildKDTree();
}
KDNode* KDNode::buildKDTree(vector<Point*> points, int depth, KDNode* p){
//DEBUG_MSG("Got " << points.size() << " points" <<endl);
if(points.empty()){
return NULL;
}
_workingAxis = depth % NUM_DIMENSIONS;
//DEBUG_MSG("Set axis="<< _workingAxis <<endl);
//Sort vector of points
sort(points.begin(), points.end(), axisSort);
int medianIndex = (points.size()>>1);
//DEBUG_MSG("medianIndex="<< medianIndex <<endl);
vector<Point*>::iterator median = points.begin()+medianIndex;
//DEBUG_MSG("Newing KDNode"<<endl);
KDNode* node = new KDNode(p);
//DEBUG_MSG("Newed"<<endl);
if(points.size() > 0){
node->topLeft = *points.front();
node->bottomRight = *points.front();
}
for(uint32_t i=0; i<points.size(); i++){
Point* p=points[i];
if(p->x < node->topLeft.x){
node->topLeft.x = p->x;
}
if(p->x > node->bottomRight.x){
node->bottomRight.x = p->x;
}
if(p->y > node->topLeft.y){
node->topLeft.y = p->y;
}
if(p->y < node->bottomRight.y){
node->bottomRight.y = p->y;
}
}
node->depth = depth;
node->direction = _workingAxis;
//DEBUG_MSG("**median"<<endl);
node->location = **median;
//DEBUG_MSG("Building left"<<endl);
vector<Point*> leftPoints = vector<Point*>(points.begin(), median);
//DEBUG_MSG("leftPoints has "<< leftPoints.size() << "elements" << endl);
node->left = buildKDTree(leftPoints, depth+1, node);
//DEBUG_MSG("Building right"<<endl);
vector<Point*> rightPoints = vector<Point*>(median+1, points.end());
//DEBUG_MSG("rightPoints has "<< rightPoints.size() << "elements" << endl);
node->right = buildKDTree(rightPoints, depth+1, node);
return node;
}
bool BkgdObsKDLoader::loadBkgdObs(QList<real> &bgIn)
{
int time;
real lat, lon, alt, u, v, w, t, qv, rhoa, qr;
real Pi = acos(-1);
KD_tree *kdTree;
QDateTime startTime = frameVector.front().getTime();
QDateTime endTime = frameVector.back().getTime();
std::cout << "Start time: " << startTime.toTime_t() << " "
<< startTime.toString("yyyy-MM-dd-HH:mm:ss").toLatin1().data() << std::endl;
std::cout << "End time: " << endTime.toTime_t() << " "
<< endTime.toString("yyyy-MM-dd-HH:mm:ss").toLatin1().data() << std::endl;
// background is in km, ROI is gridpoints
// TODO that comment doesn't seem correct. These are set to 45.0 in the config file...
iROI = configHash->value("i_background_roi").toFloat() / iincr;
jROI = configHash->value("j_background_roi").toFloat() / jincr;
maxGridDist = 3.0;
int timeProblem = 0;
int domainProblem = 0;
int debugKd = 0;
if (configHash->contains("debug_kd") ) {
debugKd = configHash->value("debug_kd").toInt();
std::cout << "*** dbugKD: " << debugKd << std::endl;
}
int debugKdStep = 0;
if (configHash->contains("debug_kd_step") ) {
debugKdStep = configHash->value("debug_kd_step").toInt();
std::cout << "*** Debug KD Step: " << debugKdStep << std::endl;
}
while( bkgdAdapter->next(time, lat, lon, alt, u, v, w, t, qv, rhoa, qr) ) {
// Process the bkgdObs into Observations
int tci;
if (! timeCheck(time, startTime, endTime, tci)) {
timeProblem++;
continue;
}
real Um = frameVector[tci].getUmean();
real Vm = frameVector[tci].getVmean();
// Get the X, Y & Z
real tcX, tcY, metX, metY;
real referenceLon = configHash->value("ref_lon").toFloat();
projection.Forward(referenceLon, frameVector[tci].getLat() , frameVector[tci].getLon(),
tcX, tcY);
projection.Forward(referenceLon, lat, lon , metX, metY);
bgX = (metX - tcX) / 1000.;
bgY = (metY - tcY) / 1000.;
real heightm = (alt > 10.0) ? alt : 10; // don't want to take log of zero below...
bgZ = heightm / 1000.;
bgRadius = sqrt(bgX * bgX + bgY * bgY);
bgTheta = 180.0 * atan2(bgY, bgX) / Pi;
if (configHash->value("allow_negative_angles") != "true")
if (bgTheta < 0)
bgTheta += 360.0;
// Make sure the ob is in the Interpolation domain
if (runMode == RUN_MODE_XYZ) {
if ((bgX < (imin - iincr - (iROI * iincr * maxGridDist))) or
(bgX > (imax + iincr + (iROI * iincr * maxGridDist))) or
(bgY < (jmin - jincr - (jROI * jincr * maxGridDist))) or
(bgY > (jmax + jincr + (jROI * jincr * maxGridDist))) or
(bgZ < kmin)) { //Allow for higher values for interpolation purposes
domainProblem++;
continue;
}
} else if (runMode == RUN_MODE_RTZ) {
if ((bgRadius < (imin - iincr - (iROI * iincr * maxGridDist))) or
(bgRadius > (imax + iincr + (iROI * iincr * maxGridDist))) or
(bgTheta < jmin - jincr - (jROI * jincr * maxGridDist)) or
(bgTheta > jmax + jincr + (jROI * jincr * maxGridDist)) or
(bgZ < kmin)) { //Exceeding the Theta domain only makes sense for sectors
domainProblem++;
continue;
}
real cylUm = (Um * bgX + Vm * bgY) / bgRadius;
real cylVm = (-Um * bgY + Vm * bgX) / bgRadius;
Um = cylUm;
Vm = cylVm;
}
// Reference states
real rhoBar = refstate->getReferenceVariable(ReferenceVariable::rhoaref, heightm);
real qBar = refstate->getReferenceVariable(ReferenceVariable::qvbhypref, heightm);
real tBar = refstate->getReferenceVariable(ReferenceVariable::tempref, heightm);
real rho = rhoa + rhoa * qv / 1000.;
real rhou = rho * (u - Um);
real rhov = rho * (v - Vm);
real rhow = rho * w;
real tprime = t - tBar;
qv = refstate->bhypTransform(qv);
real qvprime = qv - qBar;
real rhoprime = (rhoa - rhoBar) * 100;
real logZ = log(bgZ);
if (configHash->value("qr_variable") == "qr")
qr = refstate->bhypTransform(qr);
// We assume here that the background precipitation field is always zero
// real qr = 0.;
if (runMode == RUN_MODE_XYZ) {
bgIn << bgX << bgY << logZ << time << rhou << rhov << rhow << tprime << qvprime << rhoprime << qr ;
} else if (runMode == RUN_MODE_RTZ)
bgIn << bgRadius << bgTheta << logZ << time << rhou << rhov << rhow << tprime
<< qvprime << rhoprime << qr;
} // each obs
std::cout << "timeProblem: " << timeProblem << ", domainProblem: " << domainProblem
<< std::endl;
int numbgObs = bgIn.size() / 11; // 11 entries per ob
if (numbgObs <= 0) {
std::cout << "No background observations loaded" << std::endl;
return false;
}
std::cout << numbgObs << " background observations loaded" << std::endl;
if (isTrue("debug_bgIn"))
dumpBgIn(0, numbgObs, bgIn);
// All the obs are now loaded in bgIn. Build a KD tree
kdTree = buildKDTree(bgIn);
QVector<int> emptybg;
KD_real *centerLoc = new KD_real[3]; // 3 dim
int nbrMax = configHash->value("bkgd_kd_num_neighbors").toInt();
if (nbrMax <= 0) {
std::cerr << "Number of neighbors must be greater than 0." << std::endl;
return false;
}
float maxDist = configHash->value("bkgd_kd_max_distance").toFloat();
// KD tree returns the square of the distance...
maxDist *= maxDist;
// For each point on the mish
std::cout << "*** idim: " << idim << ", jdim: " << jdim << ", kdim: " << kdim << std::endl;
if (debugKd)
std::cout << "--- start of debug kd" << std::endl;
for (int ii = -1; ii < (idim); ii++) {
for (int imu = -1; imu <= 1; imu += 2) {
real iPos = imin + iincr * (ii + (0.5 * sqrt(1. / 3.) * imu + 0.5));
for (int ji = -1; ji < (jdim); ji++) {
for (int jmu = -1; jmu <= 1; jmu += 2) {
real jPos = jmin + jincr * (ji + (0.5 * sqrt(1. / 3.) * jmu + 0.5));
for (int ki = -1; ki < (kdim); ki++) {
for (int kmu = -1; kmu <= 1; kmu += 2) {
real kPos = kmin + kincr * (ki + (0.5 * sqrt(1. / 3.) * kmu + 0.5));
int bgI = (ii + 1) * 2 + (imu + 1) / 2;
int bgJ = (ji + 1) * 2 + (jmu + 1) / 2;
int bgK = (ki + 1) * 2 + (kmu + 1) / 2;
// std::cout << "iPos: " << iPos << ", jPos: " << jPos << ", kPos: " << kPos << std::endl;
// std::cout << "bgI: " << bgI << ", bgJ: " << bgJ << ", bgK " << bgK << std::endl;
// continue;
// index into bgU (flat array)
int bIndex = numVars * (idim + 1) * 2 * (jdim + 1) * 2 * bgK
+ numVars * (idim + 1) * 2 * bgJ + numVars * bgI;
// Do the KD tree here.
// give me the n nearest neighbors and average.
centerLoc[0] = iPos;
centerLoc[1] = jPos;
centerLoc[2] = kPos;
fillBguEntry(centerLoc, nbrMax, maxDist, bgIn, kdTree, bgU, bIndex, emptybg, debugKd);
if (debugKd > 0)
debugKd -= debugKdStep;
}
}
}
}
}
}
if (emptybg.size() > 0)
std::cout << "** KD left " << emptybg.size() << " holes in bgU" << std::endl;
if (debugKd)
std::cout << "--- end of debug kd" << std::endl;
if (configHash->contains("debug_bgU_overwrite"))
overwriteBgu(configHash->value("debug_bgU_overwrite").toLatin1().data());
if (isTrue("debug_bgU")) {
dumpBgU(0, uStateSize, bgU);
}
if (configHash->contains("debug_bgU_nc"))
bgu2nc(configHash->value("debug_bgU_nc").toLatin1().data(), bgU);
return true;
}
