bool cc2Point5DimEditor::RasterGrid::fillWith( ccGenericPointCloud* cloud, unsigned char projectionDimension, cc2Point5DimEditor::ProjectionType projectionType, bool interpolateEmptyCells, cc2Point5DimEditor::ProjectionType sfInterpolation/*=INVALID_PROJECTION_TYPE*/, ccProgressDialog* progressDialog/*=0*/) { if (!cloud) { assert(false); return false; } //current parameters unsigned gridTotalSize = width * height; //vertical dimension const unsigned char Z = projectionDimension; assert(Z >= 0 && Z <= 2); const unsigned char X = Z == 2 ? 0 : Z +1; const unsigned char Y = X == 2 ? 0 : X +1; //do we need to interpolate scalar fields? ccPointCloud* pc = cloud->isA(CC_TYPES::POINT_CLOUD) ? static_cast<ccPointCloud*>(cloud) : 0; bool interpolateSF = (sfInterpolation != INVALID_PROJECTION_TYPE); interpolateSF &= (pc && pc->hasScalarFields()); if (interpolateSF) { unsigned sfCount = pc->getNumberOfScalarFields(); bool memoryError = false; size_t previousCount = scalarFields.size(); if (sfCount > previousCount) { try { scalarFields.resize(sfCount,0); } catch (const std::bad_alloc&) { //not enough memory memoryError = true; } } for (size_t i=previousCount; i<sfCount; ++i) { assert(scalarFields[i] == 0); scalarFields[i] = new double[gridTotalSize]; if (!scalarFields[i]) { //not enough memory memoryError = true; break; } } if (memoryError) { ccLog::Warning(QString("[Rasterize] Failed to allocate memory for scalar fields!")); } } //filling the grid unsigned pointCount = cloud->size(); double gridMaxX = gridStep * width; double gridMaxY = gridStep * height; if (progressDialog) { progressDialog->setMethodTitle("Grid generation"); progressDialog->setInfo(qPrintable(QString("Points: %1\nCells: %2 x %3").arg(pointCount).arg(width).arg(height))); progressDialog->start(); progressDialog->show(); QCoreApplication::processEvents(); } CCLib::NormalizedProgress nProgress(progressDialog,pointCount); for (unsigned n=0; n<pointCount; ++n) { const CCVector3* P = cloud->getPoint(n); CCVector3d relativePos = CCVector3d::fromArray(P->u) - minCorner; int i = static_cast<int>(relativePos.u[X]/gridStep); int j = static_cast<int>(relativePos.u[Y]/gridStep); //specific case: if we fall exactly on the max corner of the grid box if (i == static_cast<int>(width) && relativePos.u[X] == gridMaxX) --i; if (j == static_cast<int>(height) && relativePos.u[Y] == gridMaxY) --j; //we skip points outside the box! if ( i < 0 || i >= static_cast<int>(width) || j < 0 || j >= static_cast<int>(height) ) continue; assert(i >= 0 && j >= 0); RasterCell* aCell = data[j]+i; unsigned& pointsInCell = aCell->nbPoints; if (pointsInCell) { if (P->u[Z] < aCell->minHeight) { aCell->minHeight = P->u[Z]; if (projectionType == PROJ_MINIMUM_VALUE) aCell->pointIndex = n; } else if (P->u[Z] > aCell->maxHeight) { aCell->maxHeight = P->u[Z]; if (projectionType == PROJ_MAXIMUM_VALUE) aCell->pointIndex = n; } } else { aCell->minHeight = aCell->maxHeight = P->u[Z]; aCell->pointIndex = n; } // Sum the points heights aCell->avgHeight += P->u[Z]; aCell->stdDevHeight += static_cast<double>(P->u[Z])*P->u[Z]; //scalar fields if (interpolateSF) { int pos = j*static_cast<int>(width)+i; //pos in 2D SF grid(s) assert(pos < static_cast<int>(gridTotalSize)); for (size_t k=0; k<scalarFields.size(); ++k) { if (scalarFields[k]) { CCLib::ScalarField* sf = pc->getScalarField(static_cast<unsigned>(k)); assert(sf); ScalarType sfValue = sf->getValue(n); ScalarType formerValue = static_cast<ScalarType>(scalarFields[k][pos]); if (pointsInCell && ccScalarField::ValidValue(formerValue)) { if (ccScalarField::ValidValue(sfValue)) { switch (sfInterpolation) { case PROJ_MINIMUM_VALUE: // keep the minimum value scalarFields[k][pos] = std::min<double>(formerValue,sfValue); break; case PROJ_AVERAGE_VALUE: //we sum all values (we will divide them later) scalarFields[k][pos] += sfValue; break; case PROJ_MAXIMUM_VALUE: // keep the maximum value scalarFields[k][pos] = std::max<double>(formerValue,sfValue); break; default: assert(false); break; } } } else { //for the first (vaild) point, we simply have to store its SF value (in any case) scalarFields[k][pos] = sfValue; } } } } pointsInCell++; if (!nProgress.oneStep()) { //process cancelled by user return false; } } //update SF grids for 'average' cases if (sfInterpolation == PROJ_AVERAGE_VALUE) { for (size_t k=0; k<scalarFields.size(); ++k) { if (scalarFields[k]) { double* _gridSF = scalarFields[k]; for (unsigned j=0;j<height;++j) { RasterCell* cell = data[j]; for (unsigned i=0; i<width; ++i,++cell,++_gridSF) { if (cell->nbPoints > 1) { ScalarType s = static_cast<ScalarType>(*_gridSF); if (ccScalarField::ValidValue(s)) //valid SF value { *_gridSF /= cell->nbPoints; } } } } } } } //update the main grid (average height and std.dev. computation + current 'height' value) { for (unsigned j=0; j<height; ++j) { RasterCell* cell = data[j]; for (unsigned i=0; i<width; ++i,++cell) { if (cell->nbPoints > 1) { cell->avgHeight /= cell->nbPoints; cell->stdDevHeight = sqrt(fabs(cell->stdDevHeight/cell->nbPoints - cell->avgHeight*cell->avgHeight)); } else { cell->stdDevHeight = 0; } if (cell->nbPoints != 0) { //set the right 'height' value switch (projectionType) { case PROJ_MINIMUM_VALUE: cell->h = cell->minHeight; break; case PROJ_AVERAGE_VALUE: cell->h = cell->avgHeight; break; case PROJ_MAXIMUM_VALUE: cell->h = cell->maxHeight; break; default: assert(false); break; } } } } } //compute the number of non empty cells nonEmptyCellCount = 0; { for (unsigned i=0; i<height; ++i) for (unsigned j=0; j<width; ++j) if (data[i][j].nbPoints) ++nonEmptyCellCount; } //specific case: interpolate the empty cells if (interpolateEmptyCells) { std::vector<CCVector2> the2DPoints; if (nonEmptyCellCount < 3) { ccLog::Warning("[Rasterize] Not enough non-empty cells to interpolate!"); } else if (nonEmptyCellCount < width * height) //otherwise it's useless! { try { the2DPoints.resize(nonEmptyCellCount); } catch (const std::bad_alloc&) { //out of memory ccLog::Warning("[Rasterize] Not enough memory to interpolate empty cells!"); } } //fill 2D vector with non-empty cell indexes if (!the2DPoints.empty()) { unsigned index = 0; for (unsigned j=0; j<height; ++j) { const RasterCell* cell = data[j]; for (unsigned i=0; i<width; ++i, ++cell) { if (cell->nbPoints) { //we only use the non-empty cells to interpolate the2DPoints[index++] = CCVector2(static_cast<PointCoordinateType>(i),static_cast<PointCoordinateType>(j)); } } } assert(index == nonEmptyCellCount); //mesh the '2D' points CCLib::Delaunay2dMesh delaunayMesh; char errorStr[1024]; if (delaunayMesh.buildMesh(the2DPoints,0,errorStr)) { unsigned triNum = delaunayMesh.size(); //now we are going to 'project' all triangles on the grid delaunayMesh.placeIteratorAtBegining(); for (unsigned k=0; k<triNum; ++k) { const CCLib::VerticesIndexes* tsi = delaunayMesh.getNextTriangleVertIndexes(); //get the triangle bounding box (in grid coordinates) int P[3][2]; int xMin = 0, yMin = 0, xMax = 0, yMax = 0; { for (unsigned j=0; j<3; ++j) { const CCVector2& P2D = the2DPoints[tsi->i[j]]; P[j][0] = static_cast<int>(P2D.x); P[j][1] = static_cast<int>(P2D.y); } xMin = std::min(std::min(P[0][0],P[1][0]),P[2][0]); yMin = std::min(std::min(P[0][1],P[1][1]),P[2][1]); xMax = std::max(std::max(P[0][0],P[1][0]),P[2][0]); yMax = std::max(std::max(P[0][1],P[1][1]),P[2][1]); } //now scan the cells { //pre-computation for barycentric coordinates const double& valA = data[ P[0][1] ][ P[0][0] ].h; const double& valB = data[ P[1][1] ][ P[1][0] ].h; const double& valC = data[ P[2][1] ][ P[2][0] ].h; int det = (P[1][1]-P[2][1])*(P[0][0]-P[2][0]) + (P[2][0]-P[1][0])*(P[0][1]-P[2][1]); for (int j=yMin; j<=yMax; ++j) { RasterCell* cell = data[static_cast<unsigned>(j)]; for (int i=xMin; i<=xMax; ++i) { //if the cell is empty if (!cell[i].nbPoints) { //we test if it's included or not in the current triangle //Point Inclusion in Polygon Test (inspired from W. Randolph Franklin - WRF) bool inside = false; for (int ti=0; ti<3; ++ti) { const int* P1 = P[ti]; const int* P2 = P[(ti+1)%3]; if ((P2[1] <= j &&j < P1[1]) || (P1[1] <= j && j < P2[1])) { int t = (i-P2[0])*(P1[1]-P2[1])-(P1[0]-P2[0])*(j-P2[1]); if (P1[1] < P2[1]) t = -t; if (t < 0) inside = !inside; } } //can we interpolate? if (inside) { double l1 = static_cast<double>((P[1][1]-P[2][1])*(i-P[2][0])+(P[2][0]-P[1][0])*(j-P[2][1]))/det; double l2 = static_cast<double>((P[2][1]-P[0][1])*(i-P[2][0])+(P[0][0]-P[2][0])*(j-P[2][1]))/det; double l3 = 1.0-l1-l2; cell[i].h = l1 * valA + l2 * valB + l3 * valC; assert(cell[i].h == cell[i].h); //interpolate SFs as well! for (size_t sfIndex=0; sfIndex<scalarFields.size(); ++sfIndex) { if (scalarFields[sfIndex]) { double* gridSF = scalarFields[sfIndex]; const double& sfValA = gridSF[ P[0][0] + P[0][1]*width ]; const double& sfValB = gridSF[ P[1][0] + P[1][1]*width ]; const double& sfValC = gridSF[ P[2][0] + P[2][1]*width ]; gridSF[i + j*width] = l1 * sfValA + l2 * sfValB + l3 * sfValC; } } } } } } } } } else { ccLog::Warning(QString("[Rasterize] Empty cells interpolation failed: Triangle lib. said '%1'").arg(errorStr)); } } } //computation of the average and extreme height values in the grid { minHeight = 0; maxHeight = 0; meanHeight = 0; validCellCount = 0; for (unsigned i=0; i<height; ++i) { for (unsigned j=0; j<width; ++j) { if (data[i][j].h == data[i][j].h) //valid height { double h = data[i][j].h; if (validCellCount) { if (h < minHeight) minHeight = h; else if (h > maxHeight) maxHeight = h; meanHeight += h; } else { //first valid cell meanHeight = minHeight = maxHeight = h; } ++validCellCount; } } } meanHeight /= validCellCount; } setValid(true); return true; }
QSharedPointer<DistanceMapGenerationTool::Map> DistanceMapGenerationTool::CreateMap(ccPointCloud* cloud, ccScalarField* sf, const ccGLMatrix& cloudToSurface, unsigned char revolutionAxisDim, double xStep_rad, double yStep, double yMin, double yMax, bool spherical, bool counterclockwise, FillStrategyType fillStrategy, EmptyCellFillOption emptyCellfillOption, ccMainAppInterface* app/*=0*/) { assert(cloud && sf); if (!cloud || !sf) { if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Internal error: invalid input structures!"),ccMainAppInterface::ERR_CONSOLE_MESSAGE); return QSharedPointer<Map>(0); } //invalid parameters? if (xStep_rad <= 0.0 || yStep <= 0.0 || yMax <= yMin || revolutionAxisDim > 2) { if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Internal error: invalid grid parameters!"),ccMainAppInterface::ERR_CONSOLE_MESSAGE); return QSharedPointer<Map>(0); } unsigned count = cloud->size(); if (count == 0) { if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Cloud is empty! Nothing to do!"),ccMainAppInterface::ERR_CONSOLE_MESSAGE); return QSharedPointer<Map>(0); } //revolution axis const unsigned char Z = revolutionAxisDim; //we deduce the 2 other ('horizontal') dimensions from the revolution axis const unsigned char X = (Z < 2 ? Z+1 : 0); const unsigned char Y = (X < 2 ? X+1 : 0); //grid dimensions unsigned xSteps = 0; { if (xStep_rad > 0) xSteps = static_cast<unsigned>(ceil((2 * M_PI) / xStep_rad)); if (xSteps == 0) { if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Invalid longitude step/boundaries! Can't generate a proper map!"),ccMainAppInterface::ERR_CONSOLE_MESSAGE); return QSharedPointer<Map>(0); } } unsigned ySteps = 0; { if (yStep > 0) ySteps = static_cast<unsigned>(ceil((yMax - yMin) / yStep)); if (ySteps == 0) { if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Invalid latitude step/boundaries! Can't generate a proper map!"),ccMainAppInterface::ERR_CONSOLE_MESSAGE); return QSharedPointer<Map>(0); } } unsigned cellCount = xSteps * ySteps; if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Projected map size: %1 x %2 (%3 cells)").arg(xSteps).arg(ySteps).arg(cellCount),ccMainAppInterface::STD_CONSOLE_MESSAGE); //reserve memory for the output matrix QSharedPointer<Map> grid(new Map); try { grid->resize(cellCount); } catch (const std::bad_alloc&) { if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Not enough memory!"),ccMainAppInterface::ERR_CONSOLE_MESSAGE); return QSharedPointer<Map>(0); } //update grid info ("for the records") grid->xSteps = xSteps; grid->xMin = 0.0; grid->xMax = 2.0 * M_PI; grid->xStep = xStep_rad; grid->ySteps = ySteps; grid->yMin = yMin; grid->yMax = yMax; grid->yStep = yStep; //motion direction grid->counterclockwise = counterclockwise; double ccw = (counterclockwise ? -1.0 : 1.0); for (unsigned n=0; n<count; ++n) { //we skip invalid values const ScalarType& val = sf->getValue(n); if (!CCLib::ScalarField::ValidValue(val)) continue; const CCVector3* P = cloud->getPoint(n); CCVector3 relativePos = cloudToSurface * (*P); //convert to cylindrical or spherical coordinates double x = ccw * atan2(relativePos.u[X],relativePos.u[Y]); //longitude if (x < 0.0) x += 2.0 * M_PI; double y = 0.0; if (spherical) { y = ComputeLatitude_rad(relativePos.u[X],relativePos.u[Y],relativePos.u[Z]); //latitude between 0 and pi/2 } else { y = relativePos.u[Z]; //height } int i = static_cast<int>((x-grid->xMin)/grid->xStep); int j = static_cast<int>((y-grid->yMin)/grid->yStep); //if we fall exactly on the max corner of the grid box if (i == static_cast<int>(grid->xSteps)) --i; if (j == static_cast<int>(grid->ySteps)) --j; //we skip points outside the box! if ( i < 0 || i >= static_cast<int>(grid->xSteps) || j < 0 || j >= static_cast<int>(grid->ySteps) ) { continue; } assert(i >= 0 && j >= 0); MapCell& cell = (*grid)[j*static_cast<int>(grid->xSteps)+i]; if (cell.count) //if there's already values projected in this cell { switch (fillStrategy) { case FILL_STRAT_MIN_DIST: // Set the minimum SF value if (val < cell.value) cell.value = val; break; case FILL_STRAT_AVG_DIST: // Sum the values cell.value += static_cast<double>(val); break; case FILL_STRAT_MAX_DIST: // Set the maximum SF value if (val > cell.value) cell.value = val; break; default: assert(false); break; } } else { //for the first point, we simply have to store its associated value (whatever the case) cell.value = val; } ++cell.count; //if (progressCb) // progressCb->update(30.0 * (float)n / (float)cloud->size()); } //we need to finish the average values computation if (fillStrategy == FILL_STRAT_AVG_DIST) { MapCell* cell = &grid->at(0); for (unsigned i=0; i<cellCount; ++i, ++cell) if (cell->count > 1) cell->value /= (double)cell->count; } //fill empty cells with zero? if (emptyCellfillOption == FILL_WITH_ZERO) { MapCell* cell = &grid->at(0); for (unsigned i=0; i<cellCount; ++i, ++cell) { if (cell->count == 0) { cell->value = 0.0; cell->count = 1; } } } else if (emptyCellfillOption == FILL_INTERPOLATE) { //convert the non-empty cells to a 2D point cloud unsigned fillCount = 0; { MapCell* cell = &grid->at(0); for (unsigned i=0; i<cellCount; ++i, ++cell) if (cell->count != 0) ++fillCount; } //do we really need to interpolate empty grid cells? if (fillCount) { std::vector<CCVector2> the2DPoints; try { the2DPoints.reserve(fillCount); } catch (...) { //out of memory if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Not enough memory to interpolate!"),ccMainAppInterface::ERR_CONSOLE_MESSAGE); } if (the2DPoints.capacity() == fillCount) { //fill 2D vector with non-empty cell indexes { const MapCell* cell = &grid->at(0); for (unsigned j=0; j<grid->ySteps; ++j) for (unsigned i=0; i<grid->xSteps; ++i, ++cell) if (cell->count) the2DPoints.push_back(CCVector2(static_cast<PointCoordinateType>(i),static_cast<PointCoordinateType>(j))); } //mesh the '2D' points CCLib::Delaunay2dMesh* dm = new CCLib::Delaunay2dMesh(); char errorStr[1024]; if (!dm->buildMesh(the2DPoints,0,errorStr)) { if (app) app->dispToConsole(QString("[DistanceMapGenerationTool] Interpolation failed: Triangle lib. said '%1'").arg(errorStr),ccMainAppInterface::ERR_CONSOLE_MESSAGE); } else { unsigned triNum = dm->size(); MapCell* cells = &grid->at(0); //now we are going to 'project' all triangles on the grid dm->placeIteratorAtBegining(); for (unsigned k=0; k<triNum; ++k) { const CCLib::VerticesIndexes* tsi = dm->getNextTriangleVertIndexes(); //get the triangle bounding box (in grid coordinates) int P[3][2]; int xMin=0,yMin=0,xMax=0,yMax=0; { for (unsigned j=0; j<3; ++j) { const CCVector2& P2D = the2DPoints[tsi->i[j]]; P[j][0] = static_cast<int>(P2D.x); P[j][1] = static_cast<int>(P2D.y); } xMin = std::min(std::min(P[0][0],P[1][0]),P[2][0]); yMin = std::min(std::min(P[0][1],P[1][1]),P[2][1]); xMax = std::max(std::max(P[0][0],P[1][0]),P[2][0]); yMax = std::max(std::max(P[0][1],P[1][1]),P[2][1]); } //now scan the cells { //pre-computation for barycentric coordinates const double& valA = cells[P[0][0] + P[0][1] * grid->xSteps].value; const double& valB = cells[P[1][0] + P[1][1] * grid->xSteps].value; const double& valC = cells[P[2][0] + P[2][1] * grid->xSteps].value; int det = (P[1][1]-P[2][1])*(P[0][0]-P[2][0]) + (P[2][0]-P[1][0])*(P[0][1]-P[2][1]); for (int j=yMin; j<=yMax; ++j) { MapCell* cell = cells + static_cast<unsigned>(j)*grid->xSteps; for (int i=xMin; i<=xMax; ++i) { //if the cell is empty if (!cell[i].count) { //we test if it's included or not in the current triangle //Point Inclusion in Polygon Test (inspired from W. Randolph Franklin - WRF) bool inside = false; for (int ti=0; ti<3; ++ti) { const int* P1 = P[ti]; const int* P2 = P[(ti+1)%3]; if ((P2[1] <= j &&j < P1[1]) || (P1[1] <= j && j < P2[1])) { int t = (i-P2[0])*(P1[1]-P2[1])-(P1[0]-P2[0])*(j-P2[1]); if (P1[1] < P2[1]) t = -t; if (t < 0) inside = !inside; } } //can we interpolate? if (inside) { double l1 = static_cast<double>((P[1][1]-P[2][1])*(i-P[2][0])+(P[2][0]-P[1][0])*(j-P[2][1]))/det; double l2 = static_cast<double>((P[2][1]-P[0][1])*(i-P[2][0])+(P[0][0]-P[2][0])*(j-P[2][1]))/det; double l3 = 1.0-l1-l2; cell[i].count = 1; cell[i].value = l1 * valA + l2 * valB + l3 * valC; } } } } } } } delete dm; dm = 0; } } } //update min and max values { const MapCell* cell = &grid->at(0); grid->minVal = grid->maxVal = cell->value; ++cell; for (unsigned i=1; i<cellCount; ++i, ++cell) { if (cell->value < grid->minVal) grid->minVal = cell->value; else if (cell->value > grid->maxVal) grid->maxVal = cell->value; } } //end of process return grid; }
bool ccExtru::buildUp() { unsigned count = static_cast<unsigned>(m_profile.size()); if (count < 3) return false; CCLib::Delaunay2dMesh mesh; //DGM: we check that last vertex is different from the first one! //(yes it happens ;) if (m_profile.back().x == m_profile.front().x && m_profile.back().y == m_profile.front().y) --count; char errorStr[1024]; if (!mesh.buildMesh(m_profile,count,errorStr)) { ccLog::Warning(QString("[ccPlane::buildUp] Profile triangulation failed (CClib said: '%1'").arg(errorStr)); return false; } unsigned numberOfTriangles = mesh.size(); int* triIndexes = mesh.getTriangleVertIndexesArray(); if (numberOfTriangles == 0) return false; //vertices unsigned vertCount = 2*count; //faces unsigned faceCount = 2*numberOfTriangles+2*count; //faces normals unsigned faceNormCount = 2+count; if (!init(vertCount,false,faceCount,faceNormCount)) { ccLog::Error("[ccPlane::buildUp] Not enough memory"); return false; } ccPointCloud* verts = vertices(); assert(verts); assert(m_triNormals); //bottom & top faces normals m_triNormals->addElement(ccNormalVectors::GetNormIndex(CCVector3(0.0,0.0,-1.0).u)); m_triNormals->addElement(ccNormalVectors::GetNormIndex(CCVector3(0.0,0.0,1.0).u)); //add profile vertices & normals for (unsigned i=0;i<count;++i) { const CCVector2& P = m_profile[i]; verts->addPoint(CCVector3(P.x,P.y,0)); verts->addPoint(CCVector3(P.x,P.y,m_height)); const CCVector2& PNext = m_profile[(i+1)%count]; CCVector2 N(-(PNext.y-P.y),PNext.x-P.x); N.normalize(); m_triNormals->addElement(ccNormalVectors::GetNormIndex(CCVector3(N.x,N.y,0.0).u)); } //add faces { //side faces { const int* _triIndexes = triIndexes; for (unsigned i=0;i<numberOfTriangles;++i,_triIndexes+=3) { addTriangle(_triIndexes[0]*2,_triIndexes[2]*2,_triIndexes[1]*2); addTriangleNormalIndexes(0,0,0); addTriangle(_triIndexes[0]*2+1,_triIndexes[1]*2+1,_triIndexes[2]*2+1); addTriangleNormalIndexes(1,1,1); } } //thickness { for (unsigned i=0;i<count;++i) { unsigned iNext = ((i+1)%count); addTriangle(i*2,i*2+1,iNext*2); addTriangleNormalIndexes(2+i,2+i,2+i); addTriangle(iNext*2,i*2+1,iNext*2+1); addTriangleNormalIndexes(2+i,2+i,2+i); } } } return true; }
bool ccFacet::createInternalRepresentation( CCLib::GenericIndexedCloudPersist* points, const PointCoordinateType* planeEquation/*=0*/) { assert(points); if (!points) return false; unsigned ptsCount = points->size(); if (ptsCount < 3) return false; CCLib::Neighbourhood Yk(points); //get corresponding plane if (!planeEquation) { planeEquation = Yk.getLSPlane(); if (!planeEquation) { ccLog::Warning("[ccFacet::createInternalRepresentation] Failed to compute the LS plane passing through the input points!"); return false; } } memcpy(m_planeEquation, planeEquation, sizeof(PointCoordinateType) * 4); //we project the input points on a plane std::vector<CCLib::PointProjectionTools::IndexedCCVector2> points2D; CCVector3 X, Y; //local base if (!Yk.projectPointsOn2DPlane<CCLib::PointProjectionTools::IndexedCCVector2>(points2D, nullptr, &m_center, &X, &Y)) { ccLog::Error("[ccFacet::createInternalRepresentation] Not enough memory!"); return false; } //compute resulting RMS m_rms = CCLib::DistanceComputationTools::computeCloud2PlaneDistanceRMS(points, m_planeEquation); //update the points indexes (not done by Neighbourhood::projectPointsOn2DPlane) { for (unsigned i = 0; i < ptsCount; ++i) { points2D[i].index = i; } } //try to get the points on the convex/concave hull to build the contour and the polygon { std::list<CCLib::PointProjectionTools::IndexedCCVector2*> hullPoints; if (!CCLib::PointProjectionTools::extractConcaveHull2D( points2D, hullPoints, m_maxEdgeLength*m_maxEdgeLength)) { ccLog::Error("[ccFacet::createInternalRepresentation] Failed to compute the convex hull of the input points!"); } unsigned hullPtsCount = static_cast<unsigned>(hullPoints.size()); //create vertices m_contourVertices = new ccPointCloud(); { if (!m_contourVertices->reserve(hullPtsCount)) { delete m_contourVertices; m_contourVertices = nullptr; ccLog::Error("[ccFacet::createInternalRepresentation] Not enough memory!"); return false; } //projection on the LS plane (in 3D) for (std::list<CCLib::PointProjectionTools::IndexedCCVector2*>::const_iterator it = hullPoints.begin(); it != hullPoints.end(); ++it) { m_contourVertices->addPoint(m_center + X*(*it)->x + Y*(*it)->y); } m_contourVertices->setName(DEFAULT_CONTOUR_POINTS_NAME); m_contourVertices->setLocked(true); m_contourVertices->setEnabled(false); addChild(m_contourVertices); } //we create the corresponding (3D) polyline { m_contourPolyline = new ccPolyline(m_contourVertices); if (m_contourPolyline->reserve(hullPtsCount)) { m_contourPolyline->addPointIndex(0, hullPtsCount); m_contourPolyline->setClosed(true); m_contourPolyline->setVisible(true); m_contourPolyline->setLocked(true); m_contourPolyline->setName(DEFAULT_CONTOUR_NAME); m_contourVertices->addChild(m_contourPolyline); m_contourVertices->setEnabled(true); m_contourVertices->setVisible(false); } else { delete m_contourPolyline; m_contourPolyline = nullptr; ccLog::Warning("[ccFacet::createInternalRepresentation] Not enough memory to create the contour polyline!"); } } //we create the corresponding (2D) mesh std::vector<CCVector2> hullPointsVector; try { hullPointsVector.reserve(hullPoints.size()); for (std::list<CCLib::PointProjectionTools::IndexedCCVector2*>::const_iterator it = hullPoints.begin(); it != hullPoints.end(); ++it) { hullPointsVector.push_back(**it); } } catch (...) { ccLog::Warning("[ccFacet::createInternalRepresentation] Not enough memory to create the contour mesh!"); } //if we have computed a concave hull, we must remove triangles falling outside! bool removePointsOutsideHull = (m_maxEdgeLength > 0); if (!hullPointsVector.empty() && CCLib::Delaunay2dMesh::Available()) { //compute the facet surface CCLib::Delaunay2dMesh dm; char errorStr[1024]; if (dm.buildMesh(hullPointsVector, 0, errorStr)) { if (removePointsOutsideHull) dm.removeOuterTriangles(hullPointsVector, hullPointsVector); unsigned triCount = dm.size(); assert(triCount != 0); m_polygonMesh = new ccMesh(m_contourVertices); if (m_polygonMesh->reserve(triCount)) { //import faces for (unsigned i = 0; i < triCount; ++i) { const CCLib::VerticesIndexes* tsi = dm.getTriangleVertIndexes(i); m_polygonMesh->addTriangle(tsi->i1, tsi->i2, tsi->i3); } m_polygonMesh->setVisible(true); m_polygonMesh->enableStippling(true); //unique normal for facets if (m_polygonMesh->reservePerTriangleNormalIndexes()) { NormsIndexesTableType* normsTable = new NormsIndexesTableType(); normsTable->reserve(1); CCVector3 N(m_planeEquation); normsTable->addElement(ccNormalVectors::GetNormIndex(N.u)); m_polygonMesh->setTriNormsTable(normsTable); for (unsigned i = 0; i < triCount; ++i) m_polygonMesh->addTriangleNormalIndexes(0, 0, 0); //all triangles will have the same normal! m_polygonMesh->showNormals(true); m_polygonMesh->setLocked(true); m_polygonMesh->setName(DEFAULT_POLYGON_MESH_NAME); m_contourVertices->addChild(m_polygonMesh); m_contourVertices->setEnabled(true); m_contourVertices->setVisible(false); } else { ccLog::Warning("[ccFacet::createInternalRepresentation] Not enough memory to create the polygon mesh's normals!"); } //update facet surface m_surface = CCLib::MeshSamplingTools::computeMeshArea(m_polygonMesh); } else { delete m_polygonMesh; m_polygonMesh = nullptr; ccLog::Warning("[ccFacet::createInternalRepresentation] Not enough memory to create the polygon mesh!"); } } else { ccLog::Warning(QString("[ccFacet::createInternalRepresentation] Failed to create the polygon mesh (third party lib. said '%1'").arg(errorStr)); } } } return true; }