ccComputeOctreeDlg::ccComputeOctreeDlg(const ccBBox& baseBBox, double minCellSize, QWidget* parent/*=0*/)
: QDialog(parent)
, Ui::ComputeOctreeDialog()
, m_bbEditorDlg(0)
{
setupUi(this);
headerLabel->setText(QString("Max subdivision level: %1").arg(ccOctree::MAX_OCTREE_LEVEL));
//minimum cell size
if (minCellSize > 0.0)
{
cellSizeDoubleSpinBox->setMinimum(minCellSize);
cellSizeDoubleSpinBox->setMaximum(1.0e9);
}
else
{
ccLog::Warning("[ccComputeOctreeDlg] Invalid minimum cell size specified!");
cellSizeRadioButton->setEnabled(false);
}
//custom bbox editor
if (baseBBox.isValid())
{
m_bbEditorDlg = new ccBoundingBoxEditorDlg(this);
m_bbEditorDlg->setBaseBBox(baseBBox,true);
m_bbEditorDlg->forceKeepSquare(true);
connect(customBBToolButton, SIGNAL(clicked()), m_bbEditorDlg, SLOT(exec()));
}
else
{
ccLog::Warning("[ccComputeOctreeDlg] Invalid base bounding-box specified!");
customBBRadioButton->setEnabled(false);
}
}
ccBoundingBoxEditorDlg::ccBoundingBoxEditorDlg(QWidget* parent/*=0*/)
: QDialog(parent, Qt::Tool)
, Ui::BoundingBoxEditorDialog()
, m_baseBoxIsMinimal(false)
, m_showInclusionWarning(true)
{
setupUi(this);
showBoxAxes(false);
xDoubleSpinBox->setMinimum(-1.0e9);
yDoubleSpinBox->setMinimum(-1.0e9);
zDoubleSpinBox->setMinimum(-1.0e9);
xDoubleSpinBox->setMaximum( 1.0e9);
yDoubleSpinBox->setMaximum( 1.0e9);
zDoubleSpinBox->setMaximum( 1.0e9);
dxDoubleSpinBox->setMinimum( 0.0);
dyDoubleSpinBox->setMinimum( 0.0);
dzDoubleSpinBox->setMinimum( 0.0);
dxDoubleSpinBox->setMaximum(1.0e9);
dyDoubleSpinBox->setMaximum(1.0e9);
dzDoubleSpinBox->setMaximum(1.0e9);
connect(pointTypeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(reflectChanges(int)));
connect(keepSquareCheckBox, SIGNAL(toggled(bool)), this, SLOT(squareModeActivated(bool)));
connect(okPushButton, SIGNAL(clicked()), this, SLOT(saveBoxAndAccept()));
connect(cancelPushButton, SIGNAL(clicked()), this, SLOT(cancel()));
connect(defaultPushButton, SIGNAL(clicked()), this, SLOT(resetToDefault()));
connect(lastPushButton, SIGNAL(clicked()), this, SLOT(resetToLast()));
connect(xDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateCurrentBBox(double)));
connect(yDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateCurrentBBox(double)));
connect(zDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateCurrentBBox(double)));
connect(dxDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateXWidth(double)));
connect(dyDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateYWidth(double)));
connect(dzDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateZWidth(double)));
connect(xOriXDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
connect(xOriYDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
connect(xOriZDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
connect(yOriXDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
connect(yOriYDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
connect(yOriZDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
connect(zOriXDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
connect(zOriYDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
connect(zOriZDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onAxisValueChanged(double)));
defaultPushButton->setVisible(false);
lastPushButton->setVisible(s_lastBBox.isValid());
checkBaseInclusion();
}
ccHeightGridGenerationDlg::ccHeightGridGenerationDlg(const ccBBox& gridBBox, QWidget* parent/*=0*/)
: QDialog(parent)
, Ui::HeightGridGenerationDialog()
, m_bbEditorDlg(0)
{
setupUi(this);
setWindowFlags(Qt::Tool/*Qt::Dialog | Qt::WindowStaysOnTopHint*/);
#ifndef CC_GDAL_SUPPORT
generateRasterCheckBox->setDisabled(true);
generateRasterCheckBox->setChecked(false);
#endif
connect(buttonBox, SIGNAL(accepted()), this, SLOT(saveSettings()));
connect(fillEmptyCells, SIGNAL(currentIndexChanged(int)), this, SLOT(projectionChanged(int)));
connect(generateCloudGroupBox, SIGNAL(toggled(bool)), this, SLOT(toggleFillEmptyCells(bool)));
connect(generateImageCheckBox, SIGNAL(toggled(bool)), this, SLOT(toggleFillEmptyCells(bool)));
connect(generateRasterCheckBox, SIGNAL(toggled(bool)), this, SLOT(toggleFillEmptyCells(bool)));
connect(generateASCIICheckBox, SIGNAL(toggled(bool)), this, SLOT(toggleFillEmptyCells(bool)));
connect(typeOfProjectionComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(projectionTypeChanged(int)));
//custom bbox editor
if (gridBBox.isValid())
{
m_bbEditorDlg = new ccBoundingBoxEditorDlg(this);
m_bbEditorDlg->setBaseBBox(gridBBox,false);
connect(editGridToolButton, SIGNAL(clicked()), this, SLOT(showGridBoxEditor()));
}
else
{
editGridToolButton->setEnabled(false);
}
loadSettings();
}
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;
}