PlaneClip(Triangles::const_ptr grid, IsoDataFunctor decider)
: m_coord(grid)
, m_tri(grid)
, m_decider(decider)
, haveCornerList(false)
, el(nullptr)
, cl(nullptr)
, x(nullptr)
, y(nullptr)
, z(nullptr)
, d(nullptr)
, out_cl(nullptr)
, out_el(nullptr)
, out_x(nullptr)
, out_y(nullptr)
, out_z(nullptr)
, out_d(nullptr)
{
if (grid->getNumCorners() > 0) {
haveCornerList = true;
cl = &grid->cl()[0];
}
x = &grid->x()[0];
y = &grid->y()[0];
z = &grid->z()[0];
m_outTri = Triangles::ptr(new Triangles(Object::Initialized));
m_outTri->setMeta(grid->meta());
m_outCoords = m_outTri;
}
Leveller(UnstructuredGrid::const_ptr grid, const Scalar isovalue)
: m_grid(grid)
, m_isoValue(isovalue)
, tl(nullptr)
, el(nullptr)
, cl(nullptr)
, x(nullptr)
, y(nullptr)
, z(nullptr)
, d(nullptr)
, out_cl(nullptr)
, out_x(nullptr)
, out_y(nullptr)
, out_z(nullptr)
, out_d(nullptr)
, gmin(std::numeric_limits<Scalar>::max())
, gmax(-std::numeric_limits<Scalar>::max())
{
tl = &grid->tl()[0];
el = &grid->el()[0];
cl = &grid->cl()[0];
x = &grid->x()[0];
y = &grid->y()[0];
z = &grid->z()[0];
m_triangles = Triangles::ptr(new Triangles(Object::Initialized));
m_triangles->setMeta(grid->meta());
}
bool process() {
const Index numElem = m_grid->getNumElements();
std::vector<Index> outputIdxV(numElem+1);
auto outputIdx = outputIdxV.data();
outputIdx[0] = 0;
#pragma omp parallel
{
Scalar tmin = std::numeric_limits<Scalar>::max();
Scalar tmax = -std::numeric_limits<Scalar>::max();
#pragma omp for
for (ssize_t elem=0; elem<numElem; ++elem) {
Index n = 0;
switch (tl[elem]) {
case UnstructuredGrid::HEXAHEDRON: {
n = processHexahedron(elem, 0, true /* count only */, tmin, tmax);
}
}
outputIdx[elem+1] = n;
}
#pragma omp critical
{
if (tmin < gmin)
gmin = tmin;
if (tmax > gmax)
gmax = tmax;
}
}
for (Index elem=0; elem<numElem; ++elem) {
outputIdx[elem+1] += outputIdx[elem];
}
Index numVert = outputIdx[numElem];
//std::cerr << "IsoSurface: " << numVert << " vertices" << std::endl;
m_triangles->cl().resize(numVert);
out_cl = m_triangles->cl().data();
m_triangles->x().resize(numVert);
out_x = m_triangles->x().data();
m_triangles->y().resize(numVert);
out_y = m_triangles->y().data();
m_triangles->z().resize(numVert);
out_z = m_triangles->z().data();
if (m_outData) {
m_outData->x().resize(numVert);
out_d = m_outData->x().data();
}
#pragma omp parallel for
for (Index elem = 0; elem<numElem; ++elem) {
switch (tl[elem]) {
case UnstructuredGrid::HEXAHEDRON: {
processHexahedron(elem, outputIdx[elem], false, gmin, gmax);
}
}
}
//std::cerr << "CuttingSurface: << " << m_outData->x().size() << " vert, " << m_outData->x().size() << " data elements" << std::endl;
return true;
}
bool process() {
processCoordinates();
Index numCoordsIn = m_outCoords->getNumCoords();
if (m_tri) {
const Index numElem = haveCornerList ? m_tri->getNumCorners()/3 : m_tri->getNumCoords()/3;
std::vector<Index> outIdxCorner(numElem+1), outIdxCoord(numElem+1);
outIdxCorner[0] = 0;
outIdxCoord[0] = numCoordsIn;
#pragma omp parallel for schedule (dynamic)
for (ssize_t elem=0; elem<numElem; ++elem) {
Index numCorner=0, numCoord=0;
processTriangle(elem, numCorner, numCoord, true);
outIdxCorner[elem+1] = numCorner;
outIdxCoord[elem+1] = numCoord;
}
for (Index elem=0; elem<numElem; ++elem) {
outIdxCoord[elem+1] += outIdxCoord[elem];
outIdxCorner[elem+1] += outIdxCorner[elem];
}
Index numCoord = outIdxCoord[numElem];
Index numCorner = outIdxCorner[numElem];
if (haveCornerList) {
m_outTri->cl().resize(numCorner);
out_cl = m_outTri->cl().data();
}
m_outTri->setSize(numCoord);
out_x = m_outTri->x().data();
out_y = m_outTri->y().data();
out_z = m_outTri->z().data();
if (m_outData) {
m_outData->x().resize(numCoord);
out_d = m_outData->x().data();
}
#pragma omp parallel for schedule (dynamic)
for (ssize_t elem = 0; elem<numElem; ++elem) {
processTriangle(elem, outIdxCorner[elem], outIdxCoord[elem], false);
}
//std::cerr << "CuttingSurface: << " << m_outData->x().size() << " vert, " << m_outData->x().size() << " data elements" << std::endl;
return true;
} else if (m_poly) {
const Index numElem = m_poly->getNumElements();
std::vector<Index> outIdxPoly(numElem+1), outIdxCorner(numElem+1), outIdxCoord(numElem+1);
outIdxPoly[0] = 0;
outIdxCorner[0] = 0;
outIdxCoord[0] = numCoordsIn;
#pragma omp parallel for schedule (dynamic)
for (ssize_t elem=0; elem<numElem; ++elem) {
Index numPoly=0, numCorner=0, numCoord=0;
processPolygon(elem, numPoly, numCorner, numCoord, true);
outIdxPoly[elem+1] = numPoly;
outIdxCorner[elem+1] = numCorner;
outIdxCoord[elem+1] = numCoord;
}
for (Index elem=0; elem<numElem; ++elem) {
outIdxPoly[elem+1] += outIdxPoly[elem];
outIdxCorner[elem+1] += outIdxCorner[elem];
outIdxCoord[elem+1] += outIdxCoord[elem];
}
Index numPoly = outIdxPoly[numElem];
Index numCorner = outIdxCorner[numElem];
Index numCoord = outIdxCoord[numElem];
m_outPoly->el().resize(numPoly+1);
out_el = m_outPoly->el().data();
out_el[numPoly] = numCorner;
m_outPoly->cl().resize(numCorner);
out_cl = m_outPoly->cl().data();
m_outPoly->setSize(numCoord);
out_x = m_outPoly->x().data();
out_y = m_outPoly->y().data();
out_z = m_outPoly->z().data();
if (m_outData) {
m_outData->x().resize(numCoord);
out_d = m_outData->x().data();
}
#pragma omp parallel for schedule (dynamic)
for (ssize_t elem = 0; elem<numElem; ++elem) {
processPolygon(elem, outIdxPoly[elem], outIdxCorner[elem], outIdxCoord[elem], false);
}
//std::cerr << "CuttingSurface: << " << m_outData->x().size() << " vert, " << m_outData->x().size() << " data elements" << std::endl;
return true;
}
return true;
}
