void visit(ccKdTree::BaseNode* node)
{
assert(node);
if (node && node->parent)
{
assert(node->parent->isNode()); //a leaf can't have children!
ccKdTree::Node* parent = static_cast<ccKdTree::Node*>(node->parent);
//we choose the right 'side' of the box that corresponds to the parent's split plane
CCVector3& boxCorner = (parent->leftChild == node ? m_UpdatedBox.maxCorner() : m_UpdatedBox.minCorner());
//if this side has not been setup yet...
if (boxCorner.u[parent->splitDim] != boxCorner.u[parent->splitDim]) //NaN
boxCorner.u[parent->splitDim] = parent->splitValue;
visit(node->parent);
}
}
//Helper
void MakeSquare(ccBBox& box, int pivotType, int defaultDim = -1)
{
assert(defaultDim<3);
assert(pivotType>=0 && pivotType<3);
CCVector3 W = box.getDiagVec();
if (W.x != W.y || W.x != W.z)
{
if (defaultDim < 0)
{
//we take the largest one!
defaultDim = 0;
if (W.u[1] > W.u[defaultDim])
defaultDim = 1;
if (W.u[2] > W.u[defaultDim])
defaultDim = 2;
}
CCVector3 newW(W.u[defaultDim], W.u[defaultDim], W.u[defaultDim]);
switch(pivotType)
{
case 0: //min corner
{
CCVector3 A = box.minCorner();
box = ccBBox(A, A + newW);
}
break;
case 1: //center
{
CCVector3 C = box.getCenter();
box = ccBBox(C - newW / 2.0, C + newW / 2.0);
}
break;
case 2: //max corner
{
CCVector3 B = box.maxCorner();
box = ccBBox(B-newW,B);
}
break;
}
}
}
bool ccVolumeCalcTool::ComputeVolume( ccRasterGrid& grid,
ccGenericPointCloud* ground,
ccGenericPointCloud* ceil,
const ccBBox& gridBox,
unsigned char vertDim,
double gridStep,
unsigned gridWidth,
unsigned gridHeight,
ccRasterGrid::ProjectionType projectionType,
ccRasterGrid::EmptyCellFillOption emptyCellFillStrategy,
ccVolumeCalcTool::ReportInfo& reportInfo,
double groundHeight = std::numeric_limits<double>::quiet_NaN(),
double ceilHeight = std::numeric_limits<double>::quiet_NaN(),
QWidget* parentWidget/*=0*/)
{
if ( gridStep <= 1.0e-8
|| gridWidth == 0
|| gridHeight == 0
|| vertDim > 2)
{
assert(false);
ccLog::Warning("[Volume] Invalid input parameters");
return false;
}
if (!ground && !ceil)
{
assert(false);
ccLog::Warning("[Volume] No valid input cloud");
return false;
}
if (!gridBox.isValid())
{
ccLog::Warning("[Volume] Invalid bounding-box");
return false;
}
//grid size
unsigned gridTotalSize = gridWidth * gridHeight;
if (gridTotalSize == 1)
{
if (parentWidget && QMessageBox::question(parentWidget, "Unexpected grid size", "The generated grid will only have 1 cell! Do you want to proceed anyway?", QMessageBox::Yes, QMessageBox::No) == QMessageBox::No)
return false;
}
else if (gridTotalSize > 10000000)
{
if (parentWidget && QMessageBox::question(parentWidget, "Big grid size", "The generated grid will have more than 10.000.000 cells! Do you want to proceed anyway?", QMessageBox::Yes, QMessageBox::No) == QMessageBox::No)
return false;
}
//memory allocation
CCVector3d minCorner = CCVector3d::fromArray(gridBox.minCorner().u);
if (!grid.init(gridWidth, gridHeight, gridStep, minCorner))
{
//not enough memory
return SendError("Not enough memory", parentWidget);
}
//progress dialog
QScopedPointer<ccProgressDialog> pDlg(0);
if (parentWidget)
{
pDlg.reset(new ccProgressDialog(true, parentWidget));
}
ccRasterGrid groundRaster;
if (ground)
{
if (!groundRaster.init(gridWidth, gridHeight, gridStep, minCorner))
{
//not enough memory
return SendError("Not enough memory", parentWidget);
}
if (groundRaster.fillWith( ground,
vertDim,
projectionType,
emptyCellFillStrategy == ccRasterGrid::INTERPOLATE,
ccRasterGrid::INVALID_PROJECTION_TYPE,
pDlg.data()))
{
groundRaster.fillEmptyCells(emptyCellFillStrategy, groundHeight);
ccLog::Print(QString("[Volume] Ground raster grid: size: %1 x %2 / heights: [%3 ; %4]").arg(groundRaster.width).arg(groundRaster.height).arg(groundRaster.minHeight).arg(groundRaster.maxHeight));
}
else
{
return false;
}
}
//ceil
ccRasterGrid ceilRaster;
if (ceil)
{
if (!ceilRaster.init(gridWidth, gridHeight, gridStep, minCorner))
{
//not enough memory
return SendError("Not enough memory", parentWidget);
}
if (ceilRaster.fillWith(ceil,
vertDim,
projectionType,
emptyCellFillStrategy == ccRasterGrid::INTERPOLATE,
ccRasterGrid::INVALID_PROJECTION_TYPE,
pDlg.data()))
{
ceilRaster.fillEmptyCells(emptyCellFillStrategy, ceilHeight);
ccLog::Print(QString("[Volume] Ceil raster grid: size: %1 x %2 / heights: [%3 ; %4]").arg(ceilRaster.width).arg(ceilRaster.height).arg(ceilRaster.minHeight).arg(ceilRaster.maxHeight));
}
else
{
return false;
}
}
//update grid and compute volume
{
if (pDlg)
{
pDlg->setMethodTitle(QObject::tr("Volume computation"));
pDlg->setInfo(QObject::tr("Cells: %1 x %2").arg(grid.width).arg(grid.height));
pDlg->start();
pDlg->show();
QCoreApplication::processEvents();
}
CCLib::NormalizedProgress nProgress(pDlg.data(), grid.width * grid.height);
size_t ceilNonMatchingCount = 0;
size_t groundNonMatchingCount = 0;
size_t cellCount = 0;
//at least one of the grid is based on a cloud
grid.nonEmptyCellCount = 0;
for (unsigned i = 0; i < grid.height; ++i)
{
for (unsigned j = 0; j < grid.width; ++j)
{
ccRasterCell& cell = grid.rows[i][j];
bool validGround = true;
cell.minHeight = groundHeight;
if (ground)
{
cell.minHeight = groundRaster.rows[i][j].h;
validGround = std::isfinite(cell.minHeight);
}
bool validCeil = true;
cell.maxHeight = ceilHeight;
if (ceil)
{
cell.maxHeight = ceilRaster.rows[i][j].h;
validCeil = std::isfinite(cell.maxHeight);
}
if (validGround && validCeil)
{
cell.h = cell.maxHeight - cell.minHeight;
cell.nbPoints = 1;
reportInfo.volume += cell.h;
if (cell.h < 0)
{
reportInfo.removedVolume -= cell.h;
}
else if (cell.h > 0)
{
reportInfo.addedVolume += cell.h;
}
reportInfo.surface += 1.0;
++grid.nonEmptyCellCount; //= matching count
++cellCount;
}
else
{
if (validGround)
{
++cellCount;
++groundNonMatchingCount;
}
else if (validCeil)
{
++cellCount;
++ceilNonMatchingCount;
}
cell.h = std::numeric_limits<double>::quiet_NaN();
cell.nbPoints = 0;
}
cell.avgHeight = (groundHeight + ceilHeight) / 2;
cell.stdDevHeight = 0;
if (pDlg && !nProgress.oneStep())
{
ccLog::Warning("[Volume] Process cancelled by the user");
return false;
}
}
}
grid.validCellCount = grid.nonEmptyCellCount;
//count the average number of valid neighbors
{
size_t validNeighborsCount = 0;
size_t count = 0;
for (unsigned i = 1; i < grid.height - 1; ++i)
{
for (unsigned j = 1; j < grid.width - 1; ++j)
{
ccRasterCell& cell = grid.rows[i][j];
if (cell.h == cell.h)
{
for (unsigned k = i - 1; k <= i + 1; ++k)
{
for (unsigned l = j - 1; l <= j + 1; ++l)
{
if (k != i || l != j)
{
ccRasterCell& otherCell = grid.rows[k][l];
if (std::isfinite(otherCell.h))
{
++validNeighborsCount;
}
}
}
}
++count;
}
}
}
if (count)
{
reportInfo.averageNeighborsPerCell = static_cast<double>(validNeighborsCount) / count;
}
}
reportInfo.matchingPrecent = static_cast<float>(grid.validCellCount * 100) / cellCount;
reportInfo.groundNonMatchingPercent = static_cast<float>(groundNonMatchingCount * 100) / cellCount;
reportInfo.ceilNonMatchingPercent = static_cast<float>(ceilNonMatchingCount * 100) / cellCount;
float cellArea = static_cast<float>(grid.gridStep * grid.gridStep);
reportInfo.volume *= cellArea;
reportInfo.addedVolume *= cellArea;
reportInfo.removedVolume *= cellArea;
reportInfo.surface *= cellArea;
}
grid.setValid(true);
return true;
}
GetCellBBoxVisitor()
{
//invalidate the initial bounding box
m_UpdatedBox.maxCorner() = CCVector3(PC_NAN,PC_NAN,PC_NAN);
m_UpdatedBox.minCorner() = CCVector3(PC_NAN,PC_NAN,PC_NAN);
}