CCCoreLib源码、lib、dll（vs2019编译器）适用于QtCreator工程打开

// SPDX-License-Identifier: LGPL-2.0-or-later // Copyright © EDF R&D / TELECOM ParisTech (ENST-TSI) #include <DgmOctree.h> //local #include <CCMiscTools.h> #include <GenericProgressCallback.h> #include <ParallelSort.h> #include <RayAndBox.h> #include <ReferenceCloud.h> #include <ScalarField.h> //system #include <cstdio> #include <utility> //DGM: tests in progress //#define COMPUTE_NN_SEARCH_STATISTICS //#define ADAPTATIVE_BINARY_SEARCH #ifndef CC_DEBUG //enables multi-threading handling (Release only) //requires TBB or QtConcurrent #if defined(CC_CORE_LIB_USES_QT_CONCURRENT) #define ENABLE_MT_OCTREE #include <QThread> #include <QThreadPool> #include <QtConcurrentMap> #include <QCoreApplication> #elif defined(CC_CORE_LIB_USES_TBB) #define ENABLE_MT_OCTREE #include <algorithm> #include <tbb/parallel_for.h> #endif #endif // #ifndef CC_DEBUG namespace CCCoreLib { /**********************************/ /* PRE COMPUTED VALUES AND TABLES */ /**********************************/ //! Const value: ln(2) static const double LOG_NAT_2 = log(2.0); //! Pre-computed bit shift values (one for each level) struct BitShiftValues { //! Default initialization BitShiftValues() { //we compute all possible values for (unsigned char level = 0; level <= DgmOctree::MAX_OCTREE_LEVEL; ++level) { values[level] = (3 * (DgmOctree::MAX_OCTREE_LEVEL - level)); } } //! Values unsigned char values[DgmOctree::MAX_OCTREE_LEVEL + 1]; }; static BitShiftValues PRE_COMPUTED_BIT_SHIFT_VALUES; //! Pre-computed cell codes for all potential cell positions (along a unique dimension) struct MonoDimensionalCellCodes { //! Total number of positions/values /** There are 1024 possible values at level 10, and 2M. at level 21. \warning Never pass a 'constant initializer' by reference **/ static const int VALUE_COUNT = DgmOctree::MAX_OCTREE_LENGTH; //! Default initialization MonoDimensionalCellCodes() { //we compute all possible values for cell codes //(along a unique dimension, the other ones are just shifted) for (int value = 0; value < VALUE_COUNT; ++value) { int mask = VALUE_COUNT; DgmOctree::CellCode code = 0; for (unsigned char k = 0; k < DgmOctree::MAX_OCTREE_LEVEL; k++) { mask >>= 1; code <<= 3; if (value & mask) { code |= 1; } } values[value] = code; } //we compute all possible masks as well! (all dimensions) //DgmOctree::CellCode baseMask = (1 << (3 * DgmOctree::MAX_OCTREE_LEVEL)); //for (int level = DgmOctree::MAX_OCTREE_LEVEL; level >= 0; --level) //{ // masks[level] = baseMask - 1; // baseMask >>= 3; //} } //! Mono-dimensional cell codes DgmOctree::CellCode values[VALUE_COUNT]; //! Mono-dimensional cell masks //DgmOctree::CellCode masks[DgmOctree::MAX_OCTREE_LEVEL + 1]; }; static MonoDimensionalCellCodes PRE_COMPUTED_POS_CODES; #ifdef ENABLE_MT_OCTREE //! Octree cell description helper struct struct octreeCellDesc { DgmOctree::CellCode truncatedCode; unsigned i1, i2; unsigned char level; }; //! Structure containing objects needed to run octree operations in parallel struct MultiThreadingWrapper { DgmOctree* octree = nullptr; DgmOctree::octreeCellFunc cell_func = nullptr; void** userParams = nullptr; GenericProgressCallback* progressCb = nullptr; NormalizedProgress* normProgressCb = nullptr; bool cellFunc_success = true; void launchOctreeCellFunc(const octreeCellDesc& desc) { //skip cell if process is aborted/has failed if (!cellFunc_success) { return; } const DgmOctree::cellsContainer& pointsAndCodes = octree->pointsAndTheirCellCodes(); //cell descriptor DgmOctree::octreeCell cell(octree); cell.level = desc.level; cell.index = desc.i1; cell.truncatedCode = desc.truncatedCode; if (cell.points->reserve(desc.i2 - desc.i1 + 1)) { for (unsigned i = desc.i1; i <= desc.i2; ++i) { cell.points->addPointIndex(pointsAndCodes[i].theIndex); } cellFunc_success &= (*cell_func)(cell, userParams, normProgressCb); if (normProgressCb) { QCoreApplication::processEvents(QEventLoop::EventLoopExec); // to allow the GUI to refresh itself } } else { cellFunc_success = false; } if (!cellFunc_success) { //TODO: display a message to make clear that the cancel order has been acknowledged! if (progressCb) { if (progressCb->textCanBeEdited()) { progressCb->setInfo("Cancelling..."); } } //if (normProgressCb) //{ // if (!normProgressCb->oneStep()) // { // cellFunc_success = false; // return; // } //} } } }; #endif } using namespace CCCoreLib; /**********************************/ /* STATIC ACCESSORS */ /**********************************/ unsigned char DgmOctree::GET_BIT_SHIFT(unsigned char level) { //return (3 * (DgmOctree::MAX_OCTREE_LEVEL - level)); return PRE_COMPUTED_BIT_SHIFT_VALUES.values[level]; } int DgmOctree::OCTREE_LENGTH(int level) { return (1 << level); } DgmOctree::CellCode DgmOctree::GenerateTruncatedCellCode(const Tuple3i& cellPos, unsigned char level) { assert( cellPos.x >= 0 && cellPos.x < MonoDimensionalCellCodes::VALUE_COUNT && cellPos.y >= 0 && cellPos.y < MonoDimensionalCellCodes::VALUE_COUNT && cellPos.z >= 0 && cellPos.z < MonoDimensionalCellCodes::VALUE_COUNT); const unsigned char shift = MAX_OCTREE_LEVEL - level; return ( PRE_COMPUTED_POS_CODES.values[cellPos.x << shift] | (PRE_COMPUTED_POS_CODES.values[cellPos.y << shift] << 1) | (PRE_COMPUTED_POS_CODES.values[cellPos.z << shift] << 2) ) >> GET_BIT_SHIFT(level); } #ifndef OCTREE_CODES_64_BITS DgmOctree::CellCode DgmOctree::GenerateTruncatedCellCode(const Tuple3s& cellPos, unsigned char level) { assert( cellPos.x >= 0 && cellPos.x < MonoDimensionalCellCodes::VALUE_COUNT && cellPos.y >= 0 && cellPos.y < MonoDimensionalCellCodes::VALUE_COUNT && cellPos.z >= 0 && cellPos.z < MonoDimensionalCellCodes::VALUE_COUNT); const unsigned char shift = MAX_OCTREE_LEVEL - level; return ( PRE_COMPUTED_POS_CODES.values[cellPos.x << shift] | (PRE_COMPUTED_POS_CODES.values[cellPos.y << shift] << 1) | (PRE_COMPUTED_POS_CODES.values[cellPos.z << shift] << 2) ) >> GET_BIT_SHIFT(level); } #endif static inline DgmOctree::CellCode GenerateCellCodeForDim(int pos) { return PRE_COMPUTED_POS_CODES.values[pos]; } bool DgmOctree::MultiThreadSupport() { #ifdef ENABLE_MT_OCTREE return true; #else return false; #endif } /**********************************/ /* EVERYTHING ELSE! */ /**********************************/ DgmOctree::DgmOctree(GenericIndexedCloudPersist* cloud) : m_theAssociatedCloud(cloud) , m_numberOfProjectedPoints(0) , m_nearestPow2(0) , m_MT_wrapper(nullptr) { clear(); #ifdef ENABLE_MT_OCTREE m_MT_wrapper = new MultiThreadingWrapper; #endif assert(m_theAssociatedCloud); } DgmOctree::~DgmOctree() { #ifdef ENABLE_MT_OCTREE delete m_MT_wrapper; m_MT_wrapper = nullptr; #endif } void DgmOctree::clear() { //reset internal tables m_dimMin = m_pointsMin = m_dimMax = m_pointsMax = CCVector3(0, 0, 0); m_numberOfProjectedPoints = 0; m_nearestPow2 = 0; m_thePointsAndTheirCellCodes.resize(0); memset(m_fillIndexes, 0, sizeof(int)*(MAX_OCTREE_LEVEL + 1) * 6); memset(m_cellSize, 0, sizeof(PointCoordinateType)*(MAX_OCTREE_LEVEL + 2)); updateCellCountTable(); } int DgmOctree::build(GenericProgressCallback* progressCb) { if (!m_theAssociatedCloud) { assert(false); return -1; } if (!m_thePointsAndTheirCellCodes.empty()) { clear(); } m_theAssociatedCloud->getBoundingBox(m_pointsMin, m_pointsMax); m_dimMin = m_pointsMin; m_dimMax = m_pointsMax; //we make this bounding-box cubical (+0.1% growth to avoid round-off issues when projecting points in the octree) CCMiscTools::MakeMinAndMaxCubical(m_dimMin, m_dimMax, 0.001); return genericBuild(progressCb); } int DgmOctree: