void Foam::ensightPartCells::classify(const labelList& idList)
{
// References to cell shape models
const cellModel& tet = *(cellModeller::lookup("tet"));
const cellModel& pyr = *(cellModeller::lookup("pyr"));
const cellModel& prism = *(cellModeller::lookup("prism"));
const cellModel& hex = *(cellModeller::lookup("hex"));
const polyMesh& mesh = *meshPtr_;
const cellShapeList& cellShapes = mesh.cellShapes();
offset_ = 0;
size_ = mesh.nCells();
bool limited = false;
if (&idList)
{
limited = true;
size_ = idList.size();
}
// count the shapes
label nTet = 0;
label nPyr = 0;
label nPrism = 0;
label nHex = 0;
label nPoly = 0;
// TODO: allow tet-decomposition of polyhedral cells
#if 0
label nTetDecomp = 0;
label nPyrDecomp = 0;
#endif
for (label listI = 0; listI < size_; ++listI)
{
label cellId = listI;
if (limited)
{
cellId = idList[listI];
}
const cellShape& cellShape = cellShapes[cellId];
const cellModel& cellModel = cellShape.model();
if (cellModel == tet)
{
nTet++;
}
else if (cellModel == pyr)
{
nPyr++;
}
else if (cellModel == prism)
{
nPrism++;
}
else if (cellModel == hex)
{
nHex++;
}
else
{
nPoly++;
// TODO: allow tet-decomposition of polyhedral cells
#if 0
const cell& cFaces = mesh.cells()[cellI];
forAll(cFaces, cFaceI)
{
const face& f = mesh.faces()[cFaces[cFaceI]];
label nQuads = 0;
label nTris = 0;
f.nTrianglesQuads(mesh.points(), nTris, nQuads);
nTetDecomp += nTris;
nPyrDecomp += nQuads;
}
nAddCells--;
nAddPoints++;
#endif
}
}
// we can avoid double looping, but at the cost of allocation
labelList tetCells(nTet);
labelList pyramidCells(nPyr);
labelList prismCells(nPrism);
labelList hexCells(nHex);
labelList polyCells(nPoly);
nTet = 0,
nPyr = 0;
nPrism = 0;
nHex = 0;
nPoly = 0;
// classify the shapes
for (label listI = 0; listI < size_; ++listI)
{
label cellId = listI;
if (limited)
{
cellId = idList[listI];
}
const cellShape& cellShape = cellShapes[cellId];
const cellModel& cellModel = cellShape.model();
if (cellModel == tet)
{
tetCells[nTet++] = cellId;
}
else if (cellModel == pyr)
{
pyramidCells[nPyr++] = cellId;
}
else if (cellModel == prism)
{
prismCells[nPrism++] = cellId;
}
else if (cellModel == hex)
{
hexCells[nHex++] = cellId;
}
else
{
polyCells[nPoly++] = cellId;
// TODO: allow tet-decomposition of polyhedral cells
#if 0
// Mapping from additional point to cell
addPointCellLabels_[api] = cellId;
const cell& cFaces = mesh.cells()[cellId];
forAll(cFaces, cFaceI)
{
const face& f = mesh.faces()[cFaces[cFaceI]];
label nQuads = 0;
label nTris = 0;
f.nTrianglesQuads(mesh.points(), nTris, nQuads);
nTetDecomp += nTris;
nPyrDecomp += nQuads;
}
nAddCells--;
nAddPoints++;
#endif
}
}
// MUST match with elementTypes
elemLists_.setSize(elementTypes().size());
elemLists_[tetra4Elements].transfer( tetCells );
elemLists_[pyramid5Elements].transfer( pyramidCells );
elemLists_[penta6Elements].transfer( prismCells );
elemLists_[hexa8Elements].transfer( hexCells );
elemLists_[nfacedElements].transfer( polyCells );
}
Foam::ensightPartFaces::ensightPartFaces
(
label partNumber,
const polyMesh& pMesh,
const polyPatch& pPatch
)
:
ensightPart(partNumber, pPatch.name(), pMesh)
{
isCellData_ = false;
offset_ = pPatch.start();
size_ = pPatch.size();
// count the shapes
label nTri = 0;
label nQuad = 0;
label nPoly = 0;
forAll (pPatch, patchfaceI)
{
const face& f = pMesh.faces()[patchfaceI + offset_];
if (f.size() == 3)
{
nTri++;
}
else if (f.size() == 4)
{
nQuad++;
}
else
{
nPoly++;
}
}
// we can avoid double looping, but at the cost of allocation
labelList triCells(nTri);
labelList quadCells(nQuad);
labelList polygonCells(nPoly);
nTri = 0;
nQuad = 0;
nPoly = 0;
// classify the shapes
forAll(pPatch, patchfaceI)
{
const face& f = pMesh.faces()[patchfaceI + offset_];
if (f.size() == 3)
{
triCells[nTri++] = patchfaceI;
}
else if (f.size() == 4)
{
quadCells[nQuad++] = patchfaceI;
}
else
{
polygonCells[nPoly++] = patchfaceI;
}
}
// MUST match with elementTypes
elemLists_.setSize(elementTypes().size());
elemLists_[tria3Elements].transfer( triCells );
elemLists_[quad4Elements].transfer( quadCells );
elemLists_[nsidedElements].transfer( polygonCells );
}
void QOutlineMapper::endOutline()
{
closeSubpath();
if (m_elements.isEmpty()) {
memset(&m_outline, 0, sizeof(m_outline));
return;
}
QPointF *elements = m_elements.data();
// Transform the outline
if (m_txop == QTransform::TxNone) {
// Nothing to do.
} else if (m_txop == QTransform::TxTranslate) {
for (int i = 0; i < m_elements.size(); ++i) {
QPointF &e = elements[i];
e = QPointF(e.x() + m_dx, e.y() + m_dy);
}
} else if (m_txop == QTransform::TxScale) {
for (int i = 0; i < m_elements.size(); ++i) {
QPointF &e = elements[i];
e = QPointF(m_m11 * e.x() + m_dx, m_m22 * e.y() + m_dy);
}
} else if (m_txop < QTransform::TxProject) {
for (int i = 0; i < m_elements.size(); ++i) {
QPointF &e = elements[i];
e = QPointF(m_m11 * e.x() + m_m21 * e.y() + m_dx,
m_m22 * e.y() + m_m12 * e.x() + m_dy);
}
} else {
const QVectorPath vp((qreal *)elements, m_elements.size(),
m_element_types.size() ? m_element_types.data() : 0);
QPainterPath path = vp.convertToPainterPath();
path = QTransform(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33).map(path);
if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL))
path.setFillRule(Qt::WindingFill);
uint old_txop = m_txop;
m_txop = QTransform::TxNone;
if (path.isEmpty())
m_valid = false;
else
convertPath(path);
m_txop = old_txop;
return;
}
if (m_round_coords) {
// round coordinates to match outlines drawn with drawLine_midpoint_i
for (int i = 0; i < m_elements.size(); ++i)
elements[i] = QPointF(qFloor(elements[i].x() + aliasedCoordinateDelta),
qFloor(elements[i].y() + aliasedCoordinateDelta));
}
controlPointRect = boundingRect(elements, m_elements.size());
#ifdef QT_DEBUG_CONVERT
printf(" - control point rect (%.2f, %.2f) %.2f x %.2f, clip=(%d,%d, %dx%d)\n",
controlPointRect.x(), controlPointRect.y(),
controlPointRect.width(), controlPointRect.height(),
m_clip_rect.x(), m_clip_rect.y(), m_clip_rect.width(), m_clip_rect.height());
#endif
// Check for out of dev bounds...
const bool do_clip = !m_in_clip_elements && ((controlPointRect.left() < -QT_RASTER_COORD_LIMIT
|| controlPointRect.right() > QT_RASTER_COORD_LIMIT
|| controlPointRect.top() < -QT_RASTER_COORD_LIMIT
|| controlPointRect.bottom() > QT_RASTER_COORD_LIMIT
|| controlPointRect.width() > QT_RASTER_COORD_LIMIT
|| controlPointRect.height() > QT_RASTER_COORD_LIMIT));
if (do_clip) {
clipElements(elements, elementTypes(), m_elements.size());
} else {
convertElements(elements, elementTypes(), m_elements.size());
}
}
void QOutlineMapper::endOutline()
{
closeSubpath();
int element_count = m_elements.size();
if (element_count == 0) {
memset(&m_outline, 0, sizeof(m_outline));
return;
}
QPointF *elements;
// Transform the outline
if (m_txop == QTransform::TxNone) {
elements = m_elements.data();
} else {
if (m_txop == QTransform::TxTranslate) {
for (int i=0; i<m_elements.size(); ++i) {
const QPointF &e = m_elements.at(i);
m_elements_dev << QPointF(e.x() + m_dx, e.y() + m_dy);
}
} else if (m_txop == QTransform::TxScale) {
for (int i=0; i<m_elements.size(); ++i) {
const QPointF &e = m_elements.at(i);
m_elements_dev << QPointF(m_m11 * e.x() + m_dx, m_m22 * e.y() + m_dy);
}
} else if (m_txop < QTransform::TxProject) {
for (int i=0; i<m_elements.size(); ++i) {
const QPointF &e = m_elements.at(i);
m_elements_dev << QPointF(m_m11 * e.x() + m_m21 * e.y() + m_dx,
m_m22 * e.y() + m_m12 * e.x() + m_dy);
}
} else {
// ## TODO: this case needs to be plain code polygonal paths
QPainterPath path;
if (m_element_types.isEmpty()) {
if (!m_elements.isEmpty())
path.moveTo(m_elements.at(0));
for (int i=1; i<m_elements.size(); ++i)
path.lineTo(m_elements.at(i));
} else {
for (int i=0; i<m_elements.size(); ++i) {
switch (m_element_types.at(i)) {
case QPainterPath::MoveToElement:
path.moveTo(m_elements.at(i));
break;
case QPainterPath::LineToElement:
path.lineTo(m_elements.at(i));
break;
case QPainterPath::CurveToElement:
path.cubicTo(m_elements.at(i), m_elements.at(i+1), m_elements.at(i+2));
i += 2;
break;
default:
Q_ASSERT(false);
break;
}
}
}
path = QTransform(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33).map(path);
if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL))
path.setFillRule(Qt::WindingFill);
uint old_txop = m_txop;
m_txop = QTransform::TxNone;
if (path.isEmpty())
m_valid = false;
else
convertPath(path);
m_txop = old_txop;
return;
}
elements = m_elements_dev.data();
}
if (m_round_coords) {
// round coordinates to match outlines drawn with drawLine_midpoint_i
for (int i = 0; i < m_elements.size(); ++i)
elements[i] = QPointF(qFloor(elements[i].x() + aliasedCoordinateDelta),
qFloor(elements[i].y() + aliasedCoordinateDelta));
}
controlPointRect = boundingRect(elements, element_count);
#ifdef QT_DEBUG_CONVERT
printf(" - control point rect (%.2f, %.2f) %.2f x %.2f\n",
controlPointRect.x(), controlPointRect.y(),
controlPointRect.width(), controlPointRect.height());
#endif
// Check for out of dev bounds...
const bool do_clip = (controlPointRect.left() < -QT_RASTER_COORD_LIMIT
|| controlPointRect.right() > QT_RASTER_COORD_LIMIT
|| controlPointRect.top() < -QT_RASTER_COORD_LIMIT
|| controlPointRect.bottom() > QT_RASTER_COORD_LIMIT);
if (do_clip) {
clipElements(elements, elementTypes(), element_count);
} else {
convertElements(elements, elementTypes(), element_count);
}
}